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

annotate mercurial/dirstate.py @ 35080:19b75779b7c3

dirstate: move management of nonnormal sets into dirstate map The dirstate map owns the nonnormal sets, and so should be the class to update them. A future implementation of the dirstate will manage these maps differently. The action of clearing ambiguous times is now entirely controlled by the dirstate map, so it moves there too. Differential Revision: https://phab.mercurial-scm.org/D1341

author	Mark Thomas <mbthomas@fb.com>
date	Wed, 15 Nov 2017 01:07:42 -0800
parents	853b7c41d19c
children	a947cf872799

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
27503 0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	8 from __future__ import absolute_import
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	9
27670 4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	10 import collections
32346 73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	11 import contextlib
27503 0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	12 import errno
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	13 import os
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	14 import stat
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	15
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	16 from .i18n import _
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	17 from .node import nullid
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	18 from . import (
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	19 encoding,
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	20 error,
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	21 match as matchmod,
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	22 pathutil,
32372 df448de7cf3b parsers: switch to policy importer Yuya Nishihara <yuya@tcha.org> parents: 32352 diff changeset	23 policy,
30304 ba2c04059317 py3: use pycompat.ossep at certain places Pulkit Goyal <7895pulkit@gmail.com> parents: 30224 diff changeset	24 pycompat,
27503 0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	25 scmutil,
31050 206532700213 txnutil: factor out the logic to read file in according to HG_PENDING FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 30634 diff changeset	26 txnutil,
27503 0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	27 util,
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	28 )
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	29
32372 df448de7cf3b parsers: switch to policy importer Yuya Nishihara <yuya@tcha.org> parents: 32352 diff changeset	30 parsers = policy.importmod(r'parsers')
df448de7cf3b parsers: switch to policy importer Yuya Nishihara <yuya@tcha.org> parents: 32352 diff changeset	31
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	32 propertycache = util.propertycache
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	33 filecache = scmutil.filecache
17733 3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608) Matt Mackall <mpm@selenic.com> parents: 17197 diff changeset	34 _rangemask = 0x7fffffff
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	35
21809 e250b8300e6e parsers: inline fields of dirstate values in C version Siddharth Agarwal <sid0@fb.com> parents: 21808 diff changeset	36 dirstatetuple = parsers.dirstatetuple
21808 7537e57f5dbd dirstate: add dirstatetuple to create dirstate values Siddharth Agarwal <sid0@fb.com> parents: 21116 diff changeset	37
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	38 class repocache(filecache):
fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	39 """filecache for files in .hg/"""
fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	40 def join(self, obj, fname):
fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	41 return obj._opener.join(fname)
4610 274c99fc629f dirstate: simplify state() Matt Mackall <mpm@selenic.com> parents: 4609 diff changeset	42
16202 53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	43 class rootcache(filecache):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	44 """filecache for files in the repository root"""
53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	45 def join(self, obj, fname):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	46 return obj._join(fname)
53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	47
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	48 def _getfsnow(vfs):
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	49 '''Get "now" timestamp on filesystem'''
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	50 tmpfd, tmpname = vfs.mkstemp()
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	51 try:
27016 448cbdab5883 util: drop statmtimesec Matt Mackall <mpm@selenic.com> parents: 26984 diff changeset	52 return os.fstat(tmpfd).st_mtime
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	53 finally:
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	54 os.close(tmpfd)
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	55 vfs.unlink(tmpname)
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	56
1559 59b3639df0a9 Convert all classes to new-style classes by deriving them from object. Eric Hopper <hopper@omnifarious.org> parents: 1541 diff changeset	57 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	58
33373 fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	59 def __init__(self, opener, ui, root, validate, sparsematchfn):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	60 '''Create a new dirstate object.
aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	61
aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	62 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	63 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	64 the dirstate.
aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	65 '''
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	66 self._opener = opener
13032 e41e2b79883d dirstate: warn on invalid parents rather than aborting Matt Mackall <mpm@selenic.com> parents: 12907 diff changeset	67 self._validate = validate
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	68 self._root = root
33373 fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	69 self._sparsematchfn = sparsematchfn
24198 3cc630be5f09 dirstate: make sure rootdir ends with directory separator (issue4557) Yuya Nishihara <yuya@tcha.org> parents: 23866 diff changeset	70 # 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	71 # UNC path pointing to root share (issue4557)
24833 cb981009d697 dirstate: use pathutil.normasprefix to ensure os.sep at the end of root FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	72 self._rootdir = pathutil.normasprefix(root)
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	73 self._dirty = False
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15670 diff changeset	74 self._lastnormaltime = 0
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	75 self._ui = ui
16200 9d4a2942a732 dirstate: add filecache support Idan Kamara <idankk86@gmail.com> parents: 16143 diff changeset	76 self._filecache = {}
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	77 self._parentwriters = 0
25226 00d426a38137 dirstate: use self._filename instead of immediate string `dirstate` FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25216 diff changeset	78 self._filename = 'dirstate'
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	79 self._pendingfilename = '%s.pending' % self._filename
29772 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	80 self._plchangecallbacks = {}
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	81 self._origpl = None
31206 49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	82 self._updatedfiles = set()
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	83
32346 73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	84 @contextlib.contextmanager
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	85 def parentchange(self):
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	86 '''Context manager for handling dirstate parents.
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	87
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	88 If an exception occurs in the scope of the context manager,
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	89 the incoherent dirstate won't be written when wlock is
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	90 released.
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	91 '''
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	92 self._parentwriters += 1
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	93 yield
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	94 # Typically we want the "undo" step of a context manager in a
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	95 # finally block so it happens even when an exception
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	96 # occurs. In this case, however, we only want to decrement
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	97 # parentwriters if the code in the with statement exits
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	98 # normally, so we don't have a try/finally here on purpose.
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	99 self._parentwriters -= 1
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	100
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	101 def beginparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	102 '''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	103 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	104 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	105 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	106 match the contents.
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	107 '''
32352 b2de7fced2fa dirstate: mark {begin,end}parentchange as deprecated (API) Augie Fackler <augie@google.com> parents: 32346 diff changeset	108 self._ui.deprecwarn('beginparentchange is obsoleted by the '
b2de7fced2fa dirstate: mark {begin,end}parentchange as deprecated (API) Augie Fackler <augie@google.com> parents: 32346 diff changeset	109 'parentchange context manager.', '4.3')
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	110 self._parentwriters += 1
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	111
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	112 def endparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	113 '''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	114 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	115 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	116 '''
32352 b2de7fced2fa dirstate: mark {begin,end}parentchange as deprecated (API) Augie Fackler <augie@google.com> parents: 32346 diff changeset	117 self._ui.deprecwarn('endparentchange is obsoleted by the '
b2de7fced2fa dirstate: mark {begin,end}parentchange as deprecated (API) Augie Fackler <augie@google.com> parents: 32346 diff changeset	118 'parentchange context manager.', '4.3')
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	119 if self._parentwriters > 0:
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	120 self._parentwriters -= 1
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	121
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	122 def pendingparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	123 '''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	124 that modify the dirstate parent.
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	125 '''
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	126 return self._parentwriters > 0
723 9e0f3ba4a9c2 Work on walk code. Bryan O'Sullivan <bos@serpentine.com> parents: 705 diff changeset	127
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	128 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	129 def _map(self):
35078 a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	130 """Return the dirstate contents (see documentation for dirstatemap)."""
34934 6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	131 self._map = dirstatemap(self._ui, self._opener, self._root)
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	132 return self._map
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	133
33373 fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	134 @property
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	135 def _sparsematcher(self):
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	136 """The matcher for the sparse checkout.
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	137
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	138 The working directory may not include every file from a manifest. The
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	139 matcher obtained by this property will match a path if it is to be
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	140 included in the working directory.
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	141 """
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	142 # TODO there is potential to cache this property. For now, the matcher
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	143 # is resolved on every access. (But the called function does use a
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	144 # cache to keep the lookup fast.)
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	145 return self._sparsematchfn()
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	146
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	147 @repocache('branch')
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	148 def _branch(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	149 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	150 return self._opener.read("branch").strip() or "default"
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25658 diff changeset	151 except IOError as inst:
15799 e43c140eb08f dirstate: propagate IOError other than ENOENT when reading branch Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15670 diff changeset	152 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	153 raise
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	154 return "default"
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	155
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	156 @property
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	157 def _pl(self):
34338 0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class Durham Goode <durham@fb.com> parents: 34337 diff changeset	158 return self._map.parents()
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	159
16143 fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15801 diff changeset	160 def dirs(self):
34677 014bd2a555c8 dirstate: remove _dirs property cache Durham Goode <durham@fb.com> parents: 34676 diff changeset	161 return self._map.dirs
16143 fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15801 diff changeset	162
16202 53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	163 @rootcache('.hgignore')
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	164 def _ignore(self):
27594 0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	165 files = self._ignorefiles()
25216 dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25163 diff changeset	166 if not files:
32605 e6ff007e107e match: introduce nevermatcher for when no ignore files are present Siddharth Agarwal <sid0@fb.com> parents: 32550 diff changeset	167 return matchmod.never(self._root, '')
25216 dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25163 diff changeset	168
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25163 diff changeset	169 pats = ['include:%s' % f for f in files]
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25163 diff changeset	170 return matchmod.match(self._root, '', [], pats, warn=self._ui.warn)
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	171
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	172 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	173 def _slash(self):
30304 ba2c04059317 py3: use pycompat.ossep at certain places Pulkit Goyal <7895pulkit@gmail.com> parents: 30224 diff changeset	174 return self._ui.configbool('ui', 'slash') and pycompat.ossep != '/'
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	175
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	176 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	177 def _checklink(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	178 return util.checklink(self._root)
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	179
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	180 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	181 def _checkexec(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	182 return util.checkexec(self._root)
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	183
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	184 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	185 def _checkcase(self):
29889 6f447b9ec263 util: rename checkcase() to fscasesensitive() (API) Martin von Zweigbergk <martinvonz@google.com> parents: 29772 diff changeset	186 return not util.fscasesensitive(self._join('.hg'))
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	187
4905 fc61495ea9cf dirstate: make wjoin function private Matt Mackall <mpm@selenic.com> parents: 4904 diff changeset	188 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	189 # 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	190 # 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	191 return self._rootdir + f
723 9e0f3ba4a9c2 Work on walk code. Bryan O'Sullivan <bos@serpentine.com> parents: 705 diff changeset	192
15337 cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	193 def flagfunc(self, buildfallback):
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	194 if self._checklink and self._checkexec:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	195 def f(x):
18869 e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	196 try:
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	197 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	198 if util.statislink(st):
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	199 return 'l'
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	200 if util.statisexec(st):
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	201 return 'x'
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	202 except OSError:
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	203 pass
15337 cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	204 return ''
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	205 return f
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	206
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	207 fallback = buildfallback()
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	208 if self._checklink:
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	209 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	210 if os.path.islink(self._join(x)):
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	211 return 'l'
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	212 if 'x' in fallback(x):
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	213 return 'x'
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	214 return ''
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	215 return f
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	216 if self._checkexec:
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	217 def f(x):
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	218 if 'l' in fallback(x):
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	219 return 'l'
14273 38af0f514134 rename util.is_exec to isexec Adrian Buehlmann <adrian@cadifra.com> parents: 14168 diff changeset	220 if util.isexec(self._join(x)):
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	221 return 'x'
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	222 return ''
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	223 return f
15337 cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	224 else:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	225 return fallback
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	226
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	227 @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	228 def _cwd(self):
33215 b7f6885cb055 dirstate: centralize _cwd handling into _cwd method FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32772 diff changeset	229 # internal config: ui.forcecwd
b7f6885cb055 dirstate: centralize _cwd handling into _cwd method FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32772 diff changeset	230 forcecwd = self._ui.config('ui', 'forcecwd')
b7f6885cb055 dirstate: centralize _cwd handling into _cwd method FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32772 diff changeset	231 if forcecwd:
b7f6885cb055 dirstate: centralize _cwd handling into _cwd method FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32772 diff changeset	232 return forcecwd
30519 20a42325fdef py3: use pycompat.getcwd() instead of os.getcwd() Pulkit Goyal <7895pulkit@gmail.com> parents: 30304 diff changeset	233 return pycompat.getcwd()
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	234
870 a82eae840447 Teach walk code about absolute paths. Bryan O'Sullivan <bos@serpentine.com> parents: 839 diff changeset	235 def getcwd(self):
26293 3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path Yuya Nishihara <yuya@tcha.org> parents: 25877 diff changeset	236 '''Return the path from which a canonical path is calculated.
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path Yuya Nishihara <yuya@tcha.org> parents: 25877 diff changeset	237
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path Yuya Nishihara <yuya@tcha.org> parents: 25877 diff changeset	238 This path should be used to resolve file patterns or to convert
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path Yuya Nishihara <yuya@tcha.org> parents: 25877 diff changeset	239 canonical paths back to file paths for display. It shouldn't be
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path Yuya Nishihara <yuya@tcha.org> parents: 25877 diff changeset	240 used to get real file paths. Use vfs functions instead.
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path Yuya Nishihara <yuya@tcha.org> parents: 25877 diff changeset	241 '''
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	242 cwd = self._cwd
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	243 if cwd == self._root:
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	244 return ''
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	245 # 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	246 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	247 if not util.endswithsep(rootsep):
30614 cfe66dcf45c0 py3: replace os.sep with pycompat.ossep (part 2 of 4) Pulkit Goyal <7895pulkit@gmail.com> parents: 30519 diff changeset	248 rootsep += pycompat.ossep
4230 c93562fb12cc Fix handling of paths when run outside the repo. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4229 diff changeset	249 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	250 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	251 else:
c93562fb12cc Fix handling of paths when run outside the repo. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4229 diff changeset	252 # 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	253 return cwd
870 a82eae840447 Teach walk code about absolute paths. Bryan O'Sullivan <bos@serpentine.com> parents: 839 diff changeset	254
4525 78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	255 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	256 if cwd is None:
78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	257 cwd = self.getcwd()
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	258 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	259 if self._slash:
19210 865beb849720 dirstate: don't overnormalize for ui.slash Matt Mackall <mpm@selenic.com> parents: 19128 diff changeset	260 return util.pconvert(path)
4527 b422b558015b Add ui.slash hgrc setting Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4525 diff changeset	261 return path
4525 78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	262
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	263 def __getitem__(self, key):
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	264 '''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	265
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	266 States are:
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	267 n normal
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	268 m needs merging
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	269 r marked for removal
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	270 a marked for addition
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	271 ? not tracked
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	272 '''
4906 30847b8af7ca dirstate: add __contains__ and make __getitem__ more useful Matt Mackall <mpm@selenic.com> parents: 4905 diff changeset	273 return self._map.get(key, ("?",))[0]
220 3113a94c1bff change dircache into dirstate mpm@selenic.com parents: 217 diff changeset	274
3113a94c1bff change dircache into dirstate mpm@selenic.com parents: 217 diff changeset	275 def __contains__(self, key):
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	276 return key in self._map
a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	277
a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	278 def __iter__(self):
33707 36d216dcae6a dirstate: simplify dirstate's __iter__ Alex Gaynor <agaynor@mozilla.com> parents: 33440 diff changeset	279 return iter(sorted(self._map))
220 3113a94c1bff change dircache into dirstate mpm@selenic.com parents: 217 diff changeset	280
32550 b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32372 diff changeset	281 def items(self):
18792 10669e24eb6c completion: add a debugpathcomplete command Bryan O'Sullivan <bryano@fb.com> parents: 18760 diff changeset	282 return self._map.iteritems()
10669e24eb6c completion: add a debugpathcomplete command Bryan O'Sullivan <bryano@fb.com> parents: 18760 diff changeset	283
32550 b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32372 diff changeset	284 iteritems = items
b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32372 diff changeset	285
227 f57519cddd3d move repo.current to dirstate.parents() mpm@selenic.com parents: 225 diff changeset	286 def parents(self):
13032 e41e2b79883d dirstate: warn on invalid parents rather than aborting Matt Mackall <mpm@selenic.com> parents: 12907 diff changeset	287 return [self._validate(p) for p in self._pl]
227 f57519cddd3d move repo.current to dirstate.parents() mpm@selenic.com parents: 225 diff changeset	288
13876 10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	289 def p1(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	290 return self._validate(self._pl[0])
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	291
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	292 def p2(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	293 return self._validate(self._pl[1])
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	294
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	295 def branch(self):
13047 6c375e07d673 branch: operate on branch names in local string space where possible Matt Mackall <mpm@selenic.com> parents: 13032 diff changeset	296 return encoding.tolocal(self._branch)
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	297
1062 6d5a62a549fa pep-0008 cleanup benoit.boissinot@ens-lyon.fr parents: 1040 diff changeset	298 def setparents(self, p1, p2=nullid):
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	299 """Set dirstate parents to p1 and p2.
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	300
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	301 When moving from two parents to one, 'm' merged entries a
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	302 adjusted to normal and previous copy records discarded and
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	303 returned by the call.
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	304
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	305 See localrepo.setparents()
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	306 """
22407 d259322a394b dirstate: add exception when calling setparent without begin/end (API) Durham Goode <durham@fb.com> parents: 22404 diff changeset	307 if self._parentwriters == 0:
22459 0c7b018d3258 dirstate: copyedit exception for no beginparentchange call Siddharth Agarwal <sid0@fb.com> parents: 22407 diff changeset	308 raise ValueError("cannot set dirstate parent without "
0c7b018d3258 dirstate: copyedit exception for no beginparentchange call Siddharth Agarwal <sid0@fb.com> parents: 22407 diff changeset	309 "calling dirstate.beginparentchange")
22407 d259322a394b dirstate: add exception when calling setparent without begin/end (API) Durham Goode <durham@fb.com> parents: 22404 diff changeset	310
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	311 self._dirty = True
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	312 oldp2 = self._pl[1]
29772 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	313 if self._origpl is None:
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	314 self._origpl = self._pl
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	315 self._map.setparents(p1, p2)
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	316 copies = {}
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	317 if oldp2 != nullid and p2 == nullid:
34674 60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	318 candidatefiles = self._map.nonnormalset.union(
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	319 self._map.otherparentset)
31278 1c97a91a18dc dirstate: track otherparent files same as nonnormal Durham Goode <durham@fb.com> parents: 31208 diff changeset	320 for f in candidatefiles:
1c97a91a18dc dirstate: track otherparent files same as nonnormal Durham Goode <durham@fb.com> parents: 31208 diff changeset	321 s = self._map.get(f)
1c97a91a18dc dirstate: track otherparent files same as nonnormal Durham Goode <durham@fb.com> parents: 31208 diff changeset	322 if s is None:
1c97a91a18dc dirstate: track otherparent files same as nonnormal Durham Goode <durham@fb.com> parents: 31208 diff changeset	323 continue
1c97a91a18dc dirstate: track otherparent files same as nonnormal Durham Goode <durham@fb.com> parents: 31208 diff changeset	324
22895 dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents Matt Mackall <mpm@selenic.com> parents: 22782 diff changeset	325 # 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	326 if s[0] == 'm':
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	327 source = self._map.copymap.get(f)
33981 5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible Michael Bolin <mbolin@fb.com> parents: 33737 diff changeset	328 if source:
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible Michael Bolin <mbolin@fb.com> parents: 33737 diff changeset	329 copies[f] = source
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	330 self.normallookup(f)
22895 dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents Matt Mackall <mpm@selenic.com> parents: 22782 diff changeset	331 # 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	332 elif s[0] == 'n' and s[2] == -2:
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	333 source = self._map.copymap.get(f)
33981 5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible Michael Bolin <mbolin@fb.com> parents: 33737 diff changeset	334 if source:
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible Michael Bolin <mbolin@fb.com> parents: 33737 diff changeset	335 copies[f] = source
22895 dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents Matt Mackall <mpm@selenic.com> parents: 22782 diff changeset	336 self.add(f)
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	337 return copies
227 f57519cddd3d move repo.current to dirstate.parents() mpm@selenic.com parents: 225 diff changeset	338
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	339 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	340 self._branch = encoding.fromlocal(branch)
29302 083e107adaac dirstate: make writing branch file out avoid ambiguity of file stat FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29301 diff changeset	341 f = self._opener('branch', 'w', atomictemp=True, checkambig=True)
16472 14a4e17f0817 dirstate: write branch file atomically Idan Kamara <idankk86@gmail.com> parents: 16323 diff changeset	342 try:
14a4e17f0817 dirstate: write branch file atomically Idan Kamara <idankk86@gmail.com> parents: 16323 diff changeset	343 f.write(self._branch + '\n')
14a4e17f0817 dirstate: write branch file atomically Idan Kamara <idankk86@gmail.com> parents: 16323 diff changeset	344 f.close()
18317 365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	345
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	346 # 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	347 # replacing the underlying file
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	348 ce = self._filecache['_branch']
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	349 if ce:
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	350 ce.refresh()
18076 3bc21f6daac4 dirstate: don't rename branch file if writing it failed Idan Kamara <idankk86@gmail.com> parents: 17984 diff changeset	351 except: # re-raises
3bc21f6daac4 dirstate: don't rename branch file if writing it failed Idan Kamara <idankk86@gmail.com> parents: 17984 diff changeset	352 f.discard()
3bc21f6daac4 dirstate: don't rename branch file if writing it failed Idan Kamara <idankk86@gmail.com> parents: 17984 diff changeset	353 raise
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	354
4613 3a645af7fb76 localrepo and dirstate: rename reload to invalidate Matt Mackall <mpm@selenic.com> parents: 4612 diff changeset	355 def invalidate(self):
32682 e696f597d02f dirstate: add docstring for invalidate Siddharth Agarwal <sid0@fb.com> parents: 32605 diff changeset	356 '''Causes the next access to reread the dirstate.
e696f597d02f dirstate: add docstring for invalidate Siddharth Agarwal <sid0@fb.com> parents: 32605 diff changeset	357
e696f597d02f dirstate: add docstring for invalidate Siddharth Agarwal <sid0@fb.com> parents: 32605 diff changeset	358 This is different from localrepo.invalidatedirstate() because it always
e696f597d02f dirstate: add docstring for invalidate Siddharth Agarwal <sid0@fb.com> parents: 32605 diff changeset	359 rereads the dirstate. Use localrepo.invalidatedirstate() if you want to
e696f597d02f dirstate: add docstring for invalidate Siddharth Agarwal <sid0@fb.com> parents: 32605 diff changeset	360 check whether the dirstate has changed before rereading it.'''
e696f597d02f dirstate: add docstring for invalidate Siddharth Agarwal <sid0@fb.com> parents: 32605 diff changeset	361
34678 e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	362 for a in ("_map", "_branch", "_ignore"):
4953 6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4952 diff changeset	363 if a in self.__dict__:
6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4952 diff changeset	364 delattr(self, a)
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15670 diff changeset	365 self._lastnormaltime = 0
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	366 self._dirty = False
31206 49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	367 self._updatedfiles.clear()
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	368 self._parentwriters = 0
29772 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	369 self._origpl = None
4375 109077e7048d When reloading the dirstate, recompute ignore information if needed. Bryan O'Sullivan <bos@serpentine.com> parents: 4374 diff changeset	370
363 ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	371 def copy(self, source, dest):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	372 """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	373 if source == dest:
deda205a00e1 Ignore dummy copies in dirstate and localrepo.filecommit() Patrick Mezard <pmezard@gmail.com> parents: 6479 diff changeset	374 return
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	375 self._dirty = True
7566 5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441) Patrick Mezard <pmezard@gmail.com> parents: 7280 diff changeset	376 if source is not None:
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	377 self._map.copymap[dest] = source
31206 49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	378 self._updatedfiles.add(source)
49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	379 self._updatedfiles.add(dest)
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	380 elif self._map.copymap.pop(dest, None):
31206 49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	381 self._updatedfiles.add(dest)
363 ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	382
ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	383 def copied(self, file):
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	384 return self._map.copymap.get(file, None)
3154 b1f10d3223c1 dirstate: add copies function Matt Mackall <mpm@selenic.com> parents: 2962 diff changeset	385
b1f10d3223c1 dirstate: add copies function Matt Mackall <mpm@selenic.com> parents: 2962 diff changeset	386 def copies(self):
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	387 return self._map.copymap
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 514 diff changeset	388
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	389 def _droppath(self, f):
34677 014bd2a555c8 dirstate: remove _dirs property cache Durham Goode <durham@fb.com> parents: 34676 diff changeset	390 if self[f] not in "?r" and "dirs" in self._map.__dict__:
014bd2a555c8 dirstate: remove _dirs property cache Durham Goode <durham@fb.com> parents: 34676 diff changeset	391 self._map.dirs.delpath(f)
2953 3d5547845158 fix issue 322. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2859 diff changeset	392
34676 bfddc3d678ae dirstate: remove _filefoldmap property cache Durham Goode <durham@fb.com> parents: 34675 diff changeset	393 if "filefoldmap" in self._map.__dict__:
26887 663eff02a876 dirstate: fix filefoldmap incosistency on file delete Mateusz Kwapich <mitrandir@fb.com> parents: 26782 diff changeset	394 normed = util.normcase(f)
34676 bfddc3d678ae dirstate: remove _filefoldmap property cache Durham Goode <durham@fb.com> parents: 34675 diff changeset	395 if normed in self._map.filefoldmap:
bfddc3d678ae dirstate: remove _filefoldmap property cache Durham Goode <durham@fb.com> parents: 34675 diff changeset	396 del self._map.filefoldmap[normed]
26887 663eff02a876 dirstate: fix filefoldmap incosistency on file delete Mateusz Kwapich <mitrandir@fb.com> parents: 26782 diff changeset	397
31206 49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	398 self._updatedfiles.add(f)
49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	399
17196 2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath() Adrian Buehlmann <adrian@cadifra.com> parents: 17094 diff changeset	400 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	401 oldstate = self[f]
17196 2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath() Adrian Buehlmann <adrian@cadifra.com> parents: 17094 diff changeset	402 if state == 'a' or oldstate == 'r':
13974 23f2736abce3 move checkfilename from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13944 diff changeset	403 scmutil.checkfilename(f)
34677 014bd2a555c8 dirstate: remove _dirs property cache Durham Goode <durham@fb.com> parents: 34676 diff changeset	404 if f in self._map.dirs:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26521 diff changeset	405 raise error.Abort(_('directory %r already in dirstate') % f)
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	406 # shadows
24635 21e1ece30f8c util: move dirs() and finddirs() from scmutil to util Drew Gottlieb <drgott@google.com> parents: 24632 diff changeset	407 for d in util.finddirs(f):
34677 014bd2a555c8 dirstate: remove _dirs property cache Durham Goode <durham@fb.com> parents: 34676 diff changeset	408 if d in self._map.dirs:
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	409 break
34188 1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	410 entry = self._map.get(d)
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	411 if entry is not None and entry[0] != 'r':
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26521 diff changeset	412 raise error.Abort(
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	413 _('file %r in dirstate clashes with %r') % (d, f))
34677 014bd2a555c8 dirstate: remove _dirs property cache Durham Goode <durham@fb.com> parents: 34676 diff changeset	414 if oldstate in "?r" and "dirs" in self._map.__dict__:
014bd2a555c8 dirstate: remove _dirs property cache Durham Goode <durham@fb.com> parents: 34676 diff changeset	415 self._map.dirs.addpath(f)
17094 c2016bae3b97 dirstate: factor common update code into _addpath Joshua Redstone <joshua.redstone@fb.com> parents: 16955 diff changeset	416 self._dirty = True
31206 49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	417 self._updatedfiles.add(f)
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	418 self._map.addfile(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	419
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	420 def normal(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	421 '''Mark a file normal and clean.'''
4905 fc61495ea9cf dirstate: make wjoin function private Matt Mackall <mpm@selenic.com> parents: 4904 diff changeset	422 s = os.lstat(self._join(f))
27016 448cbdab5883 util: drop statmtimesec Matt Mackall <mpm@selenic.com> parents: 26984 diff changeset	423 mtime = s.st_mtime
17733 3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608) Matt Mackall <mpm@selenic.com> parents: 17197 diff changeset	424 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	425 s.st_size & _rangemask, mtime & _rangemask)
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	426 self._map.copymap.pop(f, None)
34674 60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	427 if f in self._map.nonnormalset:
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	428 self._map.nonnormalset.remove(f)
13763 7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	429 if mtime > self._lastnormaltime:
7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	430 # 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	431 # 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	432 # modifications that happen within the same timeslot.
13763 7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	433 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	434
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	435 def normallookup(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	436 '''Mark a file normal, but possibly dirty.'''
34188 1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	437 if self._pl[1] != nullid:
6298 53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	438 # 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	439 # 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	440 # being removed, restore that state.
34188 1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	441 entry = self._map.get(f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	442 if entry is not None:
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	443 if entry[0] == 'r' and entry[2] in (-1, -2):
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	444 source = self._map.copymap.get(f)
34188 1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	445 if entry[2] == -1:
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	446 self.merge(f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	447 elif entry[2] == -2:
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	448 self.otherparent(f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	449 if source:
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	450 self.copy(source, f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	451 return
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	452 if entry[0] == 'm' or entry[0] == 'n' and entry[2] == -2:
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	453 return
17094 c2016bae3b97 dirstate: factor common update code into _addpath Joshua Redstone <joshua.redstone@fb.com> parents: 16955 diff changeset	454 self._addpath(f, 'n', 0, -1, -1)
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	455 self._map.copymap.pop(f, None)
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	456
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	457 def otherparent(self, f):
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	458 '''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	459 if self._pl[1] == nullid:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26521 diff changeset	460 raise error.Abort(_("setting %r to other parent "
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	461 "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	462 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	463 # merge-like
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	464 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	465 else:
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	466 # add-like
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	467 self._addpath(f, 'n', 0, -2, -1)
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	468 self._map.copymap.pop(f, None)
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	469
6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	470 def add(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	471 '''Mark a file added.'''
17196 2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath() Adrian Buehlmann <adrian@cadifra.com> parents: 17094 diff changeset	472 self._addpath(f, 'a', 0, -1, -1)
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	473 self._map.copymap.pop(f, None)
4616 70352337934e dirstate: refactor checkinterfering Matt Mackall <mpm@selenic.com> parents: 4615 diff changeset	474
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	475 def remove(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	476 '''Mark a file removed.'''
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	477 self._dirty = True
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	478 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	479 size = 0
34188 1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	480 if self._pl[1] != nullid:
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	481 entry = self._map.get(f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	482 if entry is not None:
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	483 # backup the previous state
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	484 if entry[0] == 'm': # merge
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	485 size = -1
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	486 elif entry[0] == 'n' and entry[2] == -2: # other parent
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	487 size = -2
34674 60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	488 self._map.otherparentset.add(f)
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	489 self._map.removefile(f, size)
33981 5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible Michael Bolin <mbolin@fb.com> parents: 33737 diff changeset	490 if size == 0:
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	491 self._map.copymap.pop(f, None)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	492
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	493 def merge(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	494 '''Mark a file merged.'''
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	495 if self._pl[1] == nullid:
eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	496 return self.normallookup(f)
22897 8fe74328f700 dirstate: merge falls through to otherparent Matt Mackall <mpm@selenic.com> parents: 22896 diff changeset	497 return self.otherparent(f)
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	498
14434 cc8c09855d19 dirstate: rename forget to drop Matt Mackall <mpm@selenic.com> parents: 14273 diff changeset	499 def drop(self, f):
cc8c09855d19 dirstate: rename forget to drop Matt Mackall <mpm@selenic.com> parents: 14273 diff changeset	500 '''Drop a file from the dirstate'''
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	501 if self._map.dropfile(f):
15399 41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080) Matt Mackall <mpm@selenic.com> parents: 15337 diff changeset	502 self._dirty = True
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080) Matt Mackall <mpm@selenic.com> parents: 15337 diff changeset	503 self._droppath(f)
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	504 self._map.copymap.pop(f, None)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	505
24538 24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	506 def _discoverpath(self, path, normed, ignoremissing, exists, storemap):
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	507 if exists is None:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	508 exists = os.path.lexists(os.path.join(self._root, path))
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	509 if not exists:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	510 # Maybe a path component exists
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	511 if not ignoremissing and '/' in path:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	512 d, f = path.rsplit('/', 1)
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	513 d = self._normalize(d, False, ignoremissing, None)
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	514 folded = d + "/" + f
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	515 else:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	516 # No path components, preserve original case
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	517 folded = path
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	518 else:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	519 # recursively normalize leading directory components
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	520 # against dirstate
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	521 if '/' in normed:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	522 d, f = normed.rsplit('/', 1)
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	523 d = self._normalize(d, False, ignoremissing, True)
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	524 r = self._root + "/" + d
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	525 folded = d + "/" + util.fspath(f, r)
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	526 else:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	527 folded = util.fspath(normed, self._root)
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	528 storemap[normed] = folded
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	529
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	530 return folded
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	531
24539 3a8eba78803e dirstate: introduce function to normalize just filenames Siddharth Agarwal <sid0@fb.com> parents: 24538 diff changeset	532 def _normalizefile(self, path, isknown, ignoremissing=False, exists=None):
15488 6eff984d8e76 dirstate: fix case-folding identity for traditional Unix Matt Mackall <mpm@selenic.com> parents: 15399 diff changeset	533 normed = util.normcase(path)
34676 bfddc3d678ae dirstate: remove _filefoldmap property cache Durham Goode <durham@fb.com> parents: 34675 diff changeset	534 folded = self._map.filefoldmap.get(normed, None)
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	535 if folded is None:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	536 if isknown:
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	537 folded = path
7068 57377fa7eda2 issue 1286: dirstat regression on case folding systems Petr Kodl <petrkodl@gmail.com> parents: 7034 diff changeset	538 else:
24539 3a8eba78803e dirstate: introduce function to normalize just filenames Siddharth Agarwal <sid0@fb.com> parents: 24538 diff changeset	539 folded = self._discoverpath(path, normed, ignoremissing, exists,
34676 bfddc3d678ae dirstate: remove _filefoldmap property cache Durham Goode <durham@fb.com> parents: 34675 diff changeset	540 self._map.filefoldmap)
24539 3a8eba78803e dirstate: introduce function to normalize just filenames Siddharth Agarwal <sid0@fb.com> parents: 24538 diff changeset	541 return folded
16302 49b54f1ae053 dirstate: normalize case of directory components Matt Mackall <mpm@selenic.com> parents: 16258 diff changeset	542
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	543 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	544 normed = util.normcase(path)
34676 bfddc3d678ae dirstate: remove _filefoldmap property cache Durham Goode <durham@fb.com> parents: 34675 diff changeset	545 folded = self._map.filefoldmap.get(normed, None)
24561 6514030dc686 dirstate._normalize: don't construct dirfoldmap if not necessary Siddharth Agarwal <sid0@fb.com> parents: 24560 diff changeset	546 if folded is None:
34678 e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	547 folded = self._map.dirfoldmap.get(normed, None)
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	548 if folded is None:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	549 if isknown:
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	550 folded = path
7068 57377fa7eda2 issue 1286: dirstat regression on case folding systems Petr Kodl <petrkodl@gmail.com> parents: 7034 diff changeset	551 else:
24540 25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	552 # store discovered result in dirfoldmap so that future
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	553 # normalizefile calls don't start matching directories
24538 24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	554 folded = self._discoverpath(path, normed, ignoremissing, exists,
34678 e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	555 self._map.dirfoldmap)
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	556 return folded
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	557
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	558 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	559 '''
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	560 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	561
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	562 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	563 disk, to avoid extra filesystem access.
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	564
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	565 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	566 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	567 existing path components.
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	568
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	569 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	570
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	571 - 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	572 - version of name stored on disk
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	573 - version provided via command arguments
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	574 '''
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	575
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	576 if self._checkcase:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	577 return self._normalize(path, isknown, ignoremissing)
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	578 return path
6677 9865e15febd0 Add a normalize() method to dirstate Paul Moore <p.f.moore@gmail.com> parents: 6675 diff changeset	579
5065 b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	580 def clear(self):
34933 0217f75b6e59 dirstate: move clear onto dirstatemap class Durham Goode <durham@fb.com> parents: 34678 diff changeset	581 self._map.clear()
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15670 diff changeset	582 self._lastnormaltime = 0
31206 49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	583 self._updatedfiles.clear()
5123 79373ec3f27d merge with crew-stable Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5045 5065 diff changeset	584 self._dirty = True
5065 b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	585
18760 e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	586 def rebuild(self, parent, allfiles, changedfiles=None):
25448 2bbfc2042d93 dirstate: avoid invalidating every entries when list is empty Pierre-Yves David <pierre-yves.david@fb.com> parents: 25275 diff changeset	587 if changedfiles is None:
27176 54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild Christian Delahousse <cdelahousse@fb.com> parents: 27016 diff changeset	588 # Rebuild entire dirstate
25448 2bbfc2042d93 dirstate: avoid invalidating every entries when list is empty Pierre-Yves David <pierre-yves.david@fb.com> parents: 25275 diff changeset	589 changedfiles = allfiles
27176 54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild Christian Delahousse <cdelahousse@fb.com> parents: 27016 diff changeset	590 lastnormaltime = self._lastnormaltime
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild Christian Delahousse <cdelahousse@fb.com> parents: 27016 diff changeset	591 self.clear()
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild Christian Delahousse <cdelahousse@fb.com> parents: 27016 diff changeset	592 self._lastnormaltime = lastnormaltime
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild Christian Delahousse <cdelahousse@fb.com> parents: 27016 diff changeset	593
29772 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	594 if self._origpl is None:
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	595 self._origpl = self._pl
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	596 self._map.setparents(parent, nullid)
30026 ba06562a06a2 dirstate: rebuild should update dirstate properly Mateusz Kwapich <mitrandir@fb.com> parents: 29889 diff changeset	597 for f in changedfiles:
ba06562a06a2 dirstate: rebuild should update dirstate properly Mateusz Kwapich <mitrandir@fb.com> parents: 29889 diff changeset	598 if f in allfiles:
ba06562a06a2 dirstate: rebuild should update dirstate properly Mateusz Kwapich <mitrandir@fb.com> parents: 29889 diff changeset	599 self.normallookup(f)
ba06562a06a2 dirstate: rebuild should update dirstate properly Mateusz Kwapich <mitrandir@fb.com> parents: 29889 diff changeset	600 else:
ba06562a06a2 dirstate: rebuild should update dirstate properly Mateusz Kwapich <mitrandir@fb.com> parents: 29889 diff changeset	601 self.drop(f)
ba06562a06a2 dirstate: rebuild should update dirstate properly Mateusz Kwapich <mitrandir@fb.com> parents: 29889 diff changeset	602
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	603 self._dirty = True
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	604
32750 b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32682 diff changeset	605 def identity(self):
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32682 diff changeset	606 '''Return identity of dirstate itself to detect changing in storage
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32682 diff changeset	607
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32682 diff changeset	608 If identity of previous dirstate is equal to this, writing
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32682 diff changeset	609 changes based on the former dirstate out can keep consistency.
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32682 diff changeset	610 '''
34675 c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	611 return self._map.identity
32750 b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32682 diff changeset	612
29673 52ff07e1de91 deprecation: enforce thew 'tr' argument of 'dirstate.write' (API) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 29351 diff changeset	613 def write(self, tr):
4612 17ee7407097f dirstate: simplify dirty handling Matt Mackall <mpm@selenic.com> parents: 4611 diff changeset	614 if not self._dirty:
1794 98b6c1cad58b only write the dirstate when something changed Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1755 diff changeset	615 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	616
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	617 filename = self._filename
29673 52ff07e1de91 deprecation: enforce thew 'tr' argument of 'dirstate.write' (API) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 29351 diff changeset	618 if tr:
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	619 # 'dirstate.write()' is not only for writing in-memory
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	620 # changes out, but also for dropping ambiguous timestamp.
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	621 # delayed writing re-raise "ambiguous timestamp issue".
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	622 # See also the wiki page below for detail:
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	623 # https://www.mercurial-scm.org/wiki/DirstateTransactionPlan
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	624
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	625 # emulate dropping timestamp in 'parsers.pack_dirstate'
26747 beff0b2481b3 dirstate: remove layering violation around writing dirstate out FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26746 diff changeset	626 now = _getfsnow(self._opener)
35080 19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	627 self._map.clearambiguoustimes(self._updatedfiles, now)
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	628
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	629 # emulate that all 'dirstate.normal' results are written out
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	630 self._lastnormaltime = 0
31206 49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	631 self._updatedfiles.clear()
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	632
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	633 # delay writing in-memory changes out
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	634 tr.addfilegenerator('dirstate', (self._filename,),
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	635 self._writedirstate, location='plain')
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	636 return
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	637
29301 28f37ffc0a91 dirstate: make writing dirstate file out avoid ambiguity of file stat FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29273 diff changeset	638 st = self._opener(filename, "w", atomictemp=True, checkambig=True)
26521 3f41e28a16d8 dirstate: split write to write changes into files other than .hg/dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26492 diff changeset	639 self._writedirstate(st)
3f41e28a16d8 dirstate: split write to write changes into files other than .hg/dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26492 diff changeset	640
29772 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	641 def addparentchangecallback(self, category, callback):
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	642 """add a callback to be called when the wd parents are changed
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	643
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	644 Callback will be called with the following arguments:
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	645 dirstate, (oldp1, oldp2), (newp1, newp2)
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	646
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	647 Category is a unique identifier to allow overwriting an old callback
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	648 with a newer callback.
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	649 """
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	650 self._plchangecallbacks[category] = callback
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	651
26521 3f41e28a16d8 dirstate: split write to write changes into files other than .hg/dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26492 diff changeset	652 def _writedirstate(self, st):
29772 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	653 # notify callbacks about parents change
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	654 if self._origpl is not None and self._origpl != self._pl:
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	655 for c, callback in sorted(self._plchangecallbacks.iteritems()):
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	656 callback(self, self._origpl, self._pl)
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	657 self._origpl = None
9509 e4ca8c258d9b dirstate: kill dirstate.granularity config option Adrian Buehlmann <adrian@cadifra.com> parents: 9379 diff changeset	658 # 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	659 # filesystem's notion of 'now'
27016 448cbdab5883 util: drop statmtimesec Matt Mackall <mpm@selenic.com> parents: 26984 diff changeset	660 now = util.fstat(st).st_mtime & _rangemask
27397 6c6b48aca328 dirstate: move delaywrite logic from write to _write Matt Mackall <mpm@selenic.com> parents: 27176 diff changeset	661
6c6b48aca328 dirstate: move delaywrite logic from write to _write Matt Mackall <mpm@selenic.com> parents: 27176 diff changeset	662 # enough 'delaywrite' prevents 'pack_dirstate' from dropping
6c6b48aca328 dirstate: move delaywrite logic from write to _write Matt Mackall <mpm@selenic.com> parents: 27176 diff changeset	663 # timestamp of each entries in dirstate, because of 'now > mtime'
34480 cbda631c1dde configitems: register the 'debug.dirstate.delaywrite' config Boris Feld <boris.feld@octobus.net> parents: 34408 diff changeset	664 delaywrite = self._ui.configint('debug', 'dirstate.delaywrite')
27397 6c6b48aca328 dirstate: move delaywrite logic from write to _write Matt Mackall <mpm@selenic.com> parents: 27176 diff changeset	665 if delaywrite > 0:
27398 c81675776c95 dirstate: only invoke delaywrite if relevant Matt Mackall <mpm@selenic.com> parents: 27397 diff changeset	666 # do we have any files to delay for?
c81675776c95 dirstate: only invoke delaywrite if relevant Matt Mackall <mpm@selenic.com> parents: 27397 diff changeset	667 for f, e in self._map.iteritems():
c81675776c95 dirstate: only invoke delaywrite if relevant Matt Mackall <mpm@selenic.com> parents: 27397 diff changeset	668 if e[0] == 'n' and e[3] == now:
c81675776c95 dirstate: only invoke delaywrite if relevant Matt Mackall <mpm@selenic.com> parents: 27397 diff changeset	669 import time # to avoid useless import
27399 425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds Matt Mackall <mpm@selenic.com> parents: 27398 diff changeset	670 # rather than sleep n seconds, sleep until the next
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds Matt Mackall <mpm@selenic.com> parents: 27398 diff changeset	671 # multiple of n seconds
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds Matt Mackall <mpm@selenic.com> parents: 27398 diff changeset	672 clock = time.time()
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds Matt Mackall <mpm@selenic.com> parents: 27398 diff changeset	673 start = int(clock) - (int(clock) % delaywrite)
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds Matt Mackall <mpm@selenic.com> parents: 27398 diff changeset	674 end = start + delaywrite
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds Matt Mackall <mpm@selenic.com> parents: 27398 diff changeset	675 time.sleep(end - clock)
30224 ad56071b37d4 dirstate: fix debug.dirstate.delaywrite to use the new "now" after sleeping Mads Kiilerich <madski@unity3d.com> parents: 30026 diff changeset	676 now = end # trust our estimate that the end is near now
27398 c81675776c95 dirstate: only invoke delaywrite if relevant Matt Mackall <mpm@selenic.com> parents: 27397 diff changeset	677 break
27397 6c6b48aca328 dirstate: move delaywrite logic from write to _write Matt Mackall <mpm@selenic.com> parents: 27176 diff changeset	678
34673 e2214632c3a2 dirstate: move write into dirstatemap Durham Goode <durham@fb.com> parents: 34672 diff changeset	679 self._map.write(st, now)
21026 7ee03e190c1d dirstate: inline local finish function Mads Kiilerich <madski@unity3d.com> parents: 20632 diff changeset	680 self._lastnormaltime = 0
34673 e2214632c3a2 dirstate: move write into dirstatemap Durham Goode <durham@fb.com> parents: 34672 diff changeset	681 self._dirty = False
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	682
6032 b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	683 def _dirignore(self, f):
6479 31abcae33b4f dirstate: do not ignore current directory '.' (issue 1078) Patrick Mezard <pmezard@gmail.com> parents: 6327 diff changeset	684 if f == '.':
31abcae33b4f dirstate: do not ignore current directory '.' (issue 1078) Patrick Mezard <pmezard@gmail.com> parents: 6327 diff changeset	685 return False
6032 b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	686 if self._ignore(f):
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	687 return True
24635 21e1ece30f8c util: move dirs() and finddirs() from scmutil to util Drew Gottlieb <drgott@google.com> parents: 24632 diff changeset	688 for p in util.finddirs(f):
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	689 if self._ignore(p):
6032 b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	690 return True
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	691 return False
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	692
27594 0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	693 def _ignorefiles(self):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	694 files = []
0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	695 if os.path.exists(self._join('.hgignore')):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	696 files.append(self._join('.hgignore'))
0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	697 for name, path in self._ui.configitems("ui"):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	698 if name == 'ignore' or name.startswith('ignore.'):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	699 # we need to use os.path.join here rather than self._join
0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	700 # because path is arbitrary and user-specified
0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	701 files.append(os.path.join(self._rootdir, util.expandpath(path)))
0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	702 return files
0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	703
27670 4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	704 def _ignorefileandline(self, f):
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	705 files = collections.deque(self._ignorefiles())
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	706 visited = set()
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	707 while files:
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	708 i = files.popleft()
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	709 patterns = matchmod.readpatternfile(i, self._ui.warn,
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	710 sourceinfo=True)
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	711 for pattern, lineno, line in patterns:
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	712 kind, p = matchmod._patsplit(pattern, 'glob')
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	713 if kind == "subinclude":
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	714 if p not in visited:
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	715 files.append(p)
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	716 continue
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	717 m = matchmod.match(self._root, '', [], [pattern],
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	718 warn=self._ui.warn)
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	719 if m(f):
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	720 return (i, lineno, line)
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	721 visited.add(i)
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	722 return (None, -1, "")
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file Laurent Charignon <lcharignon@fb.com> parents: 27594 diff changeset	723
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	724 def _walkexplicit(self, match, subrepos):
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	725 '''Get stat data about the files explicitly specified by match.
3529 09d99b7e4da0 simplify dirstate walking Matt Mackall <mpm@selenic.com> parents: 3223 diff changeset	726
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	727 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	728 - 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	729 listings mapping subrepos and .hg to None.
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	730 - 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	731 - 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	732 directories and that were not found.'''
6578 f242d3684f83 walk: begin refactoring badmatch handling Matt Mackall <mpm@selenic.com> parents: 6577 diff changeset	733
8681 26f133267cd7 walk: use match.bad callback for filetype messages Matt Mackall <mpm@selenic.com> parents: 8680 diff changeset	734 def badtype(mode):
8310 8417d82d3969 dirstate: translate forgotten string Simon Heimberg <simohe@besonet.ch> parents: 8261 diff changeset	735 kind = _('unknown')
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	736 if stat.S_ISCHR(mode):
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	737 kind = _('character device')
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	738 elif stat.S_ISBLK(mode):
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	739 kind = _('block device')
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	740 elif stat.S_ISFIFO(mode):
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	741 kind = _('fifo')
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	742 elif stat.S_ISSOCK(mode):
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	743 kind = _('socket')
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	744 elif stat.S_ISDIR(mode):
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	745 kind = _('directory')
8681 26f133267cd7 walk: use match.bad callback for filetype messages Matt Mackall <mpm@selenic.com> parents: 8680 diff changeset	746 return _('unsupported file type (type is %s)') % kind
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	747
19142 c3d3e4d75ec3 dirstate.walk: cache match.explicitdir and traversedir locally Siddharth Agarwal <sid0@fb.com> parents: 19137 diff changeset	748 matchedir = match.explicitdir
8676 acd69fc201a5 walk: we always have a badfn Matt Mackall <mpm@selenic.com> parents: 8675 diff changeset	749 badfn = match.bad
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	750 dmap = self._map
5000 46facb73ba8b dirstate: localize a bunch of methods for findfiles Matt Mackall <mpm@selenic.com> parents: 4965 diff changeset	751 lstat = os.lstat
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	752 getkind = stat.S_IFMT
6828 55d65a33da52 dirstate.walk: minor cleanups Matt Mackall <mpm@selenic.com> parents: 6827 diff changeset	753 dirkind = stat.S_IFDIR
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	754 regkind = stat.S_IFREG
2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	755 lnkkind = stat.S_IFLNK
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	756 join = self._join
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	757 dirsfound = []
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	758 foundadd = dirsfound.append
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	759 dirsnotfound = []
19175 63f7bd2e1a46 dirstate._walkexplicit: inline dirsnotfound.append Siddharth Agarwal <sid0@fb.com> parents: 19174 diff changeset	760 notfoundadd = dirsnotfound.append
6820 639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	761
24448 55c449345b10 match: add isexact() method to hide internals Martin von Zweigbergk <martinvonz@google.com> parents: 24212 diff changeset	762 if not match.isexact() and self._checkcase:
12907 e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440) Matt Mackall <mpm@selenic.com> parents: 12401 diff changeset	763 normalize = self._normalize
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440) Matt Mackall <mpm@selenic.com> parents: 12401 diff changeset	764 else:
18032 a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	765 normalize = None
12907 e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440) Matt Mackall <mpm@selenic.com> parents: 12401 diff changeset	766
12211 798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	767 files = sorted(match.files())
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	768 subrepos.sort()
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	769 i, j = 0, 0
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	770 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	771 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	772 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	773 i += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	774 continue
13339 22167be007ed subrepo: fix pruning of subrepo filenames in dirstate (issue2619) trbs <trbs@trbs.net> parents: 13233 diff changeset	775 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	776 del files[i]
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	777 j += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	778
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	779 if not files or '.' in files:
24521 489026bffbf6 dirstate._walkexplicit: indicate root as '.', not '' Siddharth Agarwal <sid0@fb.com> parents: 24448 diff changeset	780 files = ['.']
10176 24ce8f0c0a39 dirstate: don't check state of subrepo directories Augie Fackler <durin42@gmail.com> parents: 10145 diff changeset	781 results = dict.fromkeys(subrepos)
24ce8f0c0a39 dirstate: don't check state of subrepo directories Augie Fackler <durin42@gmail.com> parents: 10145 diff changeset	782 results['.hg'] = None
5000 46facb73ba8b dirstate: localize a bunch of methods for findfiles Matt Mackall <mpm@selenic.com> parents: 4965 diff changeset	783
23375 a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	784 alldirs = None
12211 798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	785 for ff in files:
24523 a4b81dbe73c1 dirstate._walkexplicit: don't bother normalizing '.' Siddharth Agarwal <sid0@fb.com> parents: 24522 diff changeset	786 # constructing the foldmap is expensive, so don't do it for the
a4b81dbe73c1 dirstate._walkexplicit: don't bother normalizing '.' Siddharth Agarwal <sid0@fb.com> parents: 24522 diff changeset	787 # common case where files is ['.']
a4b81dbe73c1 dirstate._walkexplicit: don't bother normalizing '.' Siddharth Agarwal <sid0@fb.com> parents: 24522 diff changeset	788 if normalize and ff != '.':
24522 18085e46caa9 dirstate._walkexplicit: drop normpath calls Siddharth Agarwal <sid0@fb.com> parents: 24521 diff changeset	789 nf = normalize(ff, False, True)
18032 a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	790 else:
24522 18085e46caa9 dirstate._walkexplicit: drop normpath calls Siddharth Agarwal <sid0@fb.com> parents: 24521 diff changeset	791 nf = ff
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	792 if nf in results:
6820 639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	793 continue
639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	794
639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	795 try:
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	796 st = lstat(join(nf))
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	797 kind = getkind(st.st_mode)
2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	798 if kind == dirkind:
8588 2624f485b9bc dirstate: set more states in step 1 of walk Simon Heimberg <simohe@besonet.ch> parents: 8521 diff changeset	799 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	800 # 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	801 results[nf] = None
19143 3cb9468535bd match: make explicitdir and traversedir None by default Siddharth Agarwal <sid0@fb.com> parents: 19142 diff changeset	802 if matchedir:
3cb9468535bd match: make explicitdir and traversedir None by default Siddharth Agarwal <sid0@fb.com> parents: 19142 diff changeset	803 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	804 foundadd((nf, ff))
12401 4cdaf1adafc8 backout most of 4f8067c94729 Matt Mackall <mpm@selenic.com> parents: 12387 diff changeset	805 elif kind == regkind or kind == lnkkind:
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	806 results[nf] = st
6828 55d65a33da52 dirstate.walk: minor cleanups Matt Mackall <mpm@selenic.com> parents: 6827 diff changeset	807 else:
8681 26f133267cd7 walk: use match.bad callback for filetype messages Matt Mackall <mpm@selenic.com> parents: 8680 diff changeset	808 badfn(ff, badtype(kind))
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	809 if nf in dmap:
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	810 results[nf] = None
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25658 diff changeset	811 except OSError as inst: # nf not found on disk - it is dirstate only
21115 1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	812 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	813 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	814 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	815 if alldirs is None:
34332 b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	816 alldirs = util.dirs(dmap._map)
23375 a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	817 if nf in alldirs:
a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	818 if matchedir:
a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	819 matchedir(nf)
a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	820 notfoundadd(nf)
8677 34df078b8b1b walk: simplify logic for badfn clause Matt Mackall <mpm@selenic.com> parents: 8676 diff changeset	821 else:
34022 d5b2beca16c0 python3: wrap all uses of <exception>.strerror with strtolocal Augie Fackler <raf@durin42.com> parents: 33981 diff changeset	822 badfn(ff, encoding.strtolocal(inst.strerror))
6820 639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	823
25877 85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	824 # Case insensitive filesystems cannot rely on lstat() failing to detect
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	825 # a case-only rename. Prune the stat object for any file that does not
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	826 # match the case in the filesystem, if there are multiple files that
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	827 # normalize to the same path.
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	828 if match.isexact() and self._checkcase:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	829 normed = {}
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	830
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	831 for f, st in results.iteritems():
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	832 if st is None:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	833 continue
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	834
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	835 nc = util.normcase(f)
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	836 paths = normed.get(nc)
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	837
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	838 if paths is None:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	839 paths = set()
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	840 normed[nc] = paths
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	841
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	842 paths.add(f)
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	843
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	844 for norm, paths in normed.iteritems():
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	845 if len(paths) > 1:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	846 for path in paths:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	847 folded = self._discoverpath(path, norm, True, None,
34678 e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	848 self._map.dirfoldmap)
25877 85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	849 if path != folded:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	850 results[path] = None
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	851
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	852 return results, dirsfound, dirsnotfound
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	853
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	854 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	855 '''
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	856 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	857 matched by match.
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	858
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	859 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	860
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	861 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	862 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	863
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	864 '''
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	865 # 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	866 # 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	867 # 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	868
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	869 if ignored:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	870 ignore = util.never
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	871 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	872 elif unknown:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	873 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	874 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	875 else:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	876 # 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	877 ignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	878 dirignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	879
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	880 matchfn = match.matchfn
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	881 matchalways = match.always()
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	882 matchtdir = match.traversedir
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	883 dmap = self._map
32208 d74b0cff94a9 osutil: proxy through util (and platform) modules (API) Yuya Nishihara <yuya@tcha.org> parents: 32177 diff changeset	884 listdir = util.listdir
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	885 lstat = os.lstat
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	886 dirkind = stat.S_IFDIR
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	887 regkind = stat.S_IFREG
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	888 lnkkind = stat.S_IFLNK
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	889 join = self._join
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	890
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	891 exact = skipstep3 = False
24448 55c449345b10 match: add isexact() method to hide internals Martin von Zweigbergk <martinvonz@google.com> parents: 24212 diff changeset	892 if match.isexact(): # match.exact
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	893 exact = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	894 dirignore = util.always # skip step 2
25234 3c346969c321 dirstate: avoid match.files() in walk() Martin von Zweigbergk <martinvonz@google.com> parents: 25227 diff changeset	895 elif match.prefix(): # match.match, no patterns
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	896 skipstep3 = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	897
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	898 if not exact and self._checkcase:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	899 normalize = self._normalize
24541 e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize Siddharth Agarwal <sid0@fb.com> parents: 24540 diff changeset	900 normalizefile = self._normalizefile
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	901 skipstep3 = False
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	902 else:
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	903 normalize = self._normalize
24541 e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize Siddharth Agarwal <sid0@fb.com> parents: 24540 diff changeset	904 normalizefile = None
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	905
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	906 # step 1: find all explicit files
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	907 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	908
19172 c6cea2e2031b dirstate.walk: pull skipstep3 out of the explicit walk code Siddharth Agarwal <sid0@fb.com> parents: 19171 diff changeset	909 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	910 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	911
6826 eca20fee0728 dirstate.walk: pull directory scanning into top-level loop Matt Mackall <mpm@selenic.com> parents: 6825 diff changeset	912 # step 2: visit subdirectories
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	913 def traverse(work, alreadynormed):
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	914 wadd = work.append
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	915 while work:
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	916 nd = work.pop()
32177 8f1a2b848b52 dirstate: optimize walk() by using match.visitdir() Martin von Zweigbergk <martinvonz@google.com> parents: 31547 diff changeset	917 if not match.visitdir(nd):
8f1a2b848b52 dirstate: optimize walk() by using match.visitdir() Martin von Zweigbergk <martinvonz@google.com> parents: 31547 diff changeset	918 continue
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	919 skip = None
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	920 if nd == '.':
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	921 nd = ''
18032 a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	922 else:
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	923 skip = '.hg'
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	924 try:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	925 entries = listdir(join(nd), stat=True, skip=skip)
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25658 diff changeset	926 except OSError as inst:
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	927 if inst.errno in (errno.EACCES, errno.ENOENT):
34022 d5b2beca16c0 python3: wrap all uses of <exception>.strerror with strtolocal Augie Fackler <raf@durin42.com> parents: 33981 diff changeset	928 match.bad(self.pathto(nd),
d5b2beca16c0 python3: wrap all uses of <exception>.strerror with strtolocal Augie Fackler <raf@durin42.com> parents: 33981 diff changeset	929 encoding.strtolocal(inst.strerror))
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	930 continue
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	931 raise
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	932 for f, kind, st in entries:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	933 if normalizefile:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	934 # even though f might be a directory, we're only
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	935 # interested in comparing it to files currently in the
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	936 # dmap -- therefore normalizefile is enough
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	937 nf = normalizefile(nd and (nd + "/" + f) or f, True,
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	938 True)
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	939 else:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	940 nf = nd and (nd + "/" + f) or f
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	941 if nf not in results:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	942 if kind == dirkind:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	943 if not ignore(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	944 if matchtdir:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	945 matchtdir(nf)
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	946 wadd(nf)
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	947 if nf in dmap and (matchalways or matchfn(nf)):
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	948 results[nf] = None
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	949 elif kind == regkind or kind == lnkkind:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	950 if nf in dmap:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	951 if matchalways or matchfn(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	952 results[nf] = st
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	953 elif ((matchalways or matchfn(nf))
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	954 and not ignore(nf)):
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	955 # unknown file -- normalize if necessary
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	956 if not alreadynormed:
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	957 nf = normalize(nf, False, True)
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	958 results[nf] = st
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	959 elif nf in dmap and (matchalways or matchfn(nf)):
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	960 results[nf] = None
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	961
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	962 for nd, d in work:
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	963 # alreadynormed means that processwork doesn't have to do any
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	964 # expensive directory normalization
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	965 alreadynormed = not normalize or nd == d
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	966 traverse([d], alreadynormed)
536 c15b4bc0a11c Refactor diffrevs/diffdir into changes mpm@selenic.com parents: 529 diff changeset	967
18812 1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3 Siddharth Agarwal <sid0@fb.com> parents: 18792 diff changeset	968 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	969 del results[s]
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3 Siddharth Agarwal <sid0@fb.com> parents: 18792 diff changeset	970 del results['.hg']
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3 Siddharth Agarwal <sid0@fb.com> parents: 18792 diff changeset	971
21115 1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	972 # 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	973 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	974 # 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	975 # 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	976 # 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	977 if not results and matchalways:
31422 2e38a88bbc6c dirstate: use list comprehension to get a list of keys Pulkit Goyal <7895pulkit@gmail.com> parents: 31278 diff changeset	978 visit = [f for f in dmap]
18815 a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3 Siddharth Agarwal <sid0@fb.com> parents: 18814 diff changeset	979 else:
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3 Siddharth Agarwal <sid0@fb.com> parents: 18814 diff changeset	980 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	981 visit.sort()
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3 Siddharth Agarwal <sid0@fb.com> parents: 18814 diff changeset	982
18625 2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	983 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	984 # 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	985 # 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	986 # 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	987 # The rest must thus be ignored or under a symlink.
33649 377e8ddaebef pathauditor: disable cache of audited paths by default (issue5628) Yuya Nishihara <yuya@tcha.org> parents: 33440 diff changeset	988 audit_path = pathutil.pathauditor(self._root, cached=True)
18625 2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	989
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	990 for nf in iter(visit):
24621 1784ca148392 dirstate.walk: don't report same file stat multiple times Martin von Zweigbergk <martinvonz@google.com> parents: 24537 diff changeset	991 # If a stat for the same file was already added with a
1784ca148392 dirstate.walk: don't report same file stat multiple times Martin von Zweigbergk <martinvonz@google.com> parents: 24537 diff changeset	992 # different case, don't add one for this, since that would
1784ca148392 dirstate.walk: don't report same file stat multiple times Martin von Zweigbergk <martinvonz@google.com> parents: 24537 diff changeset	993 # make it appear as if the file exists under both names
1784ca148392 dirstate.walk: don't report same file stat multiple times Martin von Zweigbergk <martinvonz@google.com> parents: 24537 diff changeset	994 # on disk.
24632 b2fb1403994e merge with stable Matt Mackall <mpm@selenic.com> parents: 24610 24621 diff changeset	995 if (normalizefile and
b2fb1403994e merge with stable Matt Mackall <mpm@selenic.com> parents: 24610 24621 diff changeset	996 normalizefile(nf, True, True) in results):
24621 1784ca148392 dirstate.walk: don't report same file stat multiple times Martin von Zweigbergk <martinvonz@google.com> parents: 24537 diff changeset	997 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	998 # 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	999 # under a symlink directory.
24621 1784ca148392 dirstate.walk: don't report same file stat multiple times Martin von Zweigbergk <martinvonz@google.com> parents: 24537 diff changeset	1000 elif audit_path.check(nf):
18663 05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	1001 try:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	1002 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	1003 # 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	1004 except OSError:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	1005 # file doesn't exist
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	1006 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	1007 else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	1008 # 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	1009 # 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	1010 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	1011 else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	1012 # 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	1013 # so stat and check everything we missed.
31507 4d1dd9cf0dca dirstate: use future-proof next(iter) instead of iter.next Augie Fackler <augie@google.com> parents: 31422 diff changeset	1014 iv = iter(visit)
26984 af2663680e95 dirstate: back out 502b56a9e897 Bryan O'Sullivan <bos@serpentine.com> parents: 26887 diff changeset	1015 for st in util.statfiles([join(i) for i in visit]):
31507 4d1dd9cf0dca dirstate: use future-proof next(iter) instead of iter.next Augie Fackler <augie@google.com> parents: 31422 diff changeset	1016 results[next(iv)] = st
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	1017 return results
669 8aa2a282eda4 .hgignore speedups patch incorporating Matt's feedback. mwilli2@localhost.localdomain parents: 667 diff changeset	1018
10176 24ce8f0c0a39 dirstate: don't check state of subrepo directories Augie Fackler <durin42@gmail.com> parents: 10145 diff changeset	1019 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	1020 '''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	1021 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	1022 scmutil.status and:
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1023
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1024 unsure:
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1025 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	1026 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	1027 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	1028 status.modified:
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1029 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	1030 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	1031 status.clean:
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1032 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	1033 dirstate was written
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1034 '''
6753 ed5ffb2c12f3 repo.status: eliminate list_ Matt Mackall <mpm@selenic.com> parents: 6750 diff changeset	1035 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	1036 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	1037 removed, deleted, clean = [], [], []
723 9e0f3ba4a9c2 Work on walk code. Bryan O'Sullivan <bos@serpentine.com> parents: 705 diff changeset	1038
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1039 dmap = self._map
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1040 dmap.preload()
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1041 dcontains = dmap.__contains__
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1042 dget = dmap.__getitem__
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1043 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	1044 madd = modified.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1045 aadd = added.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1046 uadd = unknown.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1047 iadd = ignored.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1048 radd = removed.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1049 dadd = deleted.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1050 cadd = clean.append
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1051 mexact = match.exact
1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1052 dirignore = self._dirignore
1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1053 checkexec = self._checkexec
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	1054 copymap = self._map.copymap
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1055 lastnormaltime = self._lastnormaltime
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1056
19191 ab9de1e8fc36 dirstate.status: avoid full walks when possible Siddharth Agarwal <sid0@fb.com> parents: 19190 diff changeset	1057 # 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	1058 # - we're listing all clean files, or
ab9de1e8fc36 dirstate.status: avoid full walks when possible Siddharth Agarwal <sid0@fb.com> parents: 19190 diff changeset	1059 # - 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	1060 # 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	1061 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	1062 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	1063 full=full).iteritems():
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1064 if not dcontains(fn):
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1065 if (listignored or mexact(fn)) and dirignore(fn):
6753 ed5ffb2c12f3 repo.status: eliminate list_ Matt Mackall <mpm@selenic.com> parents: 6750 diff changeset	1066 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	1067 iadd(fn)
19910 601944f41257 dirstate.status: return explicit unknown files even when not asked Siddharth Agarwal <sid0@fb.com> parents: 19651 diff changeset	1068 else:
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1069 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	1070 continue
6591 eda3fd322a7f dirstate: minor status cleanups Matt Mackall <mpm@selenic.com> parents: 6590 diff changeset	1071
21810 4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1072 # 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	1073 # 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	1074 # 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	1075 # 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	1076 # 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	1077 # 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	1078 # tuple members one by one.
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1079 t = dget(fn)
21810 4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1080 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	1081 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	1082 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	1083 time = t[3]
6591 eda3fd322a7f dirstate: minor status cleanups Matt Mackall <mpm@selenic.com> parents: 6590 diff changeset	1084
6818 6e93fbd847ef dirstate.walk: eliminate src from yield Matt Mackall <mpm@selenic.com> parents: 6811 diff changeset	1085 if not st and state in "nma":
6e93fbd847ef dirstate.walk: eliminate src from yield Matt Mackall <mpm@selenic.com> parents: 6811 diff changeset	1086 dadd(fn)
6e93fbd847ef dirstate.walk: eliminate src from yield Matt Mackall <mpm@selenic.com> parents: 6811 diff changeset	1087 elif state == 'n':
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	1088 if (size >= 0 and
17733 3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608) Matt Mackall <mpm@selenic.com> parents: 17197 diff changeset	1089 ((size != st.st_size and size != st.st_size & _rangemask)
25658 e93036747902 global: mass rewrite to use modern octal syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25585 diff changeset	1090 or ((mode ^ st.st_mode) & 0o100 and checkexec))
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	1091 or size == -2 # other parent
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1092 or fn in copymap):
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1093 madd(fn)
27016 448cbdab5883 util: drop statmtimesec Matt Mackall <mpm@selenic.com> parents: 26984 diff changeset	1094 elif time != st.st_mtime and time != st.st_mtime & _rangemask:
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1095 ladd(fn)
27016 448cbdab5883 util: drop statmtimesec Matt Mackall <mpm@selenic.com> parents: 26984 diff changeset	1096 elif st.st_mtime == lastnormaltime:
24181 5245caa0dcde dirstate: clarify comment about leaving normal files undef if changed 'now' Mads Kiilerich <madski@unity3d.com> parents: 23866 diff changeset	1097 # fn may have just been marked as normal and it may have
5245caa0dcde dirstate: clarify comment about leaving normal files undef if changed 'now' Mads Kiilerich <madski@unity3d.com> parents: 23866 diff changeset	1098 # changed in the same second without changing its size.
5245caa0dcde dirstate: clarify comment about leaving normal files undef if changed 'now' Mads Kiilerich <madski@unity3d.com> parents: 23866 diff changeset	1099 # This can happen if we quickly do multiple commits.
13763 7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	1100 # 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	1101 ladd(fn)
6753 ed5ffb2c12f3 repo.status: eliminate list_ Matt Mackall <mpm@selenic.com> parents: 6750 diff changeset	1102 elif listclean:
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1103 cadd(fn)
6590 9f80e062d71c status: rename type_ to state Matt Mackall <mpm@selenic.com> parents: 6589 diff changeset	1104 elif state == 'm':
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1105 madd(fn)
6590 9f80e062d71c status: rename type_ to state Matt Mackall <mpm@selenic.com> parents: 6589 diff changeset	1106 elif state == 'a':
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1107 aadd(fn)
6590 9f80e062d71c status: rename type_ to state Matt Mackall <mpm@selenic.com> parents: 6589 diff changeset	1108 elif state == 'r':
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1109 radd(fn)
1183 d9e85a75dbda Optimize dirstate walking mason@suse.com parents: 1117 diff changeset	1110
22913 cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22911 diff changeset	1111 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	1112 unknown, ignored, clean))
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1113
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1114 def matches(self, match):
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1115 '''
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1116 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	1117 '''
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1118 dmap = self._map
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1119 if match.always():
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1120 return dmap.keys()
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1121 files = match.files()
24448 55c449345b10 match: add isexact() method to hide internals Martin von Zweigbergk <martinvonz@google.com> parents: 24212 diff changeset	1122 if match.isexact():
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1123 # 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	1124 # much smaller than dmap
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1125 return [f for f in files if f in dmap]
25275 d94e403b5237 dirstate: use match.prefix() instead of 'not match.anypats()' Martin von Zweigbergk <martinvonz@google.com> parents: 25234 diff changeset	1126 if match.prefix() and all(fn in dmap for fn in files):
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1127 # 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	1128 # that
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1129 return list(files)
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1130 return [f for f in dmap if match(f)]
26632 59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1131
26746 3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26635 diff changeset	1132 def _actualfilename(self, tr):
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26635 diff changeset	1133 if tr:
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1134 return self._pendingfilename
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1135 else:
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1136 return self._filename
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1137
33440 ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1138 def savebackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1139 '''Save current dirstate into backup file'''
26746 3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26635 diff changeset	1140 filename = self._actualfilename(tr)
33440 ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1141 assert backupname != filename
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1142
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1143 # use '_writedirstate' instead of 'write' to write changes certainly,
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1144 # because the latter omits writing out if transaction is running.
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1145 # output file will be used to create backup of dirstate at this point.
31208 fc57a8b95f1b dirstate: avoid unnecessary load+dump during backup Jun Wu <quark@fb.com> parents: 31207 diff changeset	1146 if self._dirty or not self._opener.exists(filename):
fc57a8b95f1b dirstate: avoid unnecessary load+dump during backup Jun Wu <quark@fb.com> parents: 31207 diff changeset	1147 self._writedirstate(self._opener(filename, "w", atomictemp=True,
fc57a8b95f1b dirstate: avoid unnecessary load+dump during backup Jun Wu <quark@fb.com> parents: 31207 diff changeset	1148 checkambig=True))
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1149
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1150 if tr:
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1151 # ensure that subsequent tr.writepending returns True for
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1152 # changes written out above, even if dirstate is never
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1153 # changed after this
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1154 tr.addfilegenerator('dirstate', (self._filename,),
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1155 self._writedirstate, location='plain')
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1156
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1157 # ensure that pending file written above is unlinked at
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1158 # failure, even if tr.writepending isn't invoked until the
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1159 # end of this transaction
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1160 tr.registertmp(filename, location='plain')
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1161
31547 ddadb6b0b58e dirstate: use tryunlink Ryan McElroy <rmcelroy@fb.com> parents: 31507 diff changeset	1162 self._opener.tryunlink(backupname)
31207 1ef37b16b8e8 dirstate: try to use hardlink to backup dirstate Jun Wu <quark@fb.com> parents: 31206 diff changeset	1163 # hardlink backup is okay because _writedirstate is always called
1ef37b16b8e8 dirstate: try to use hardlink to backup dirstate Jun Wu <quark@fb.com> parents: 31206 diff changeset	1164 # with an "atomictemp=True" file.
1ef37b16b8e8 dirstate: try to use hardlink to backup dirstate Jun Wu <quark@fb.com> parents: 31206 diff changeset	1165 util.copyfile(self._opener.join(filename),
1ef37b16b8e8 dirstate: try to use hardlink to backup dirstate Jun Wu <quark@fb.com> parents: 31206 diff changeset	1166 self._opener.join(backupname), hardlink=True)
26632 59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1167
33440 ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1168 def restorebackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1169 '''Restore dirstate by backup file'''
26632 59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1170 # this "invalidate()" prevents "wlock.release()" from writing
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1171 # changes of dirstate out after restoring from backup file
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1172 self.invalidate()
26746 3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26635 diff changeset	1173 filename = self._actualfilename(tr)
34940 c2b30348930f dirstate: clean up when restoring identical backups Mark Thomas <mbthomas@fb.com> parents: 34935 diff changeset	1174 o = self._opener
c2b30348930f dirstate: clean up when restoring identical backups Mark Thomas <mbthomas@fb.com> parents: 34935 diff changeset	1175 if util.samefile(o.join(backupname), o.join(filename)):
c2b30348930f dirstate: clean up when restoring identical backups Mark Thomas <mbthomas@fb.com> parents: 34935 diff changeset	1176 o.unlink(backupname)
c2b30348930f dirstate: clean up when restoring identical backups Mark Thomas <mbthomas@fb.com> parents: 34935 diff changeset	1177 else:
c2b30348930f dirstate: clean up when restoring identical backups Mark Thomas <mbthomas@fb.com> parents: 34935 diff changeset	1178 o.rename(backupname, filename, checkambig=True)
26632 59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1179
33440 ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1180 def clearbackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1181 '''Clear backup file'''
ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1182 self._opener.unlink(backupname)
34332 b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1183
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1184 class dirstatemap(object):
35078 a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1185 """Map encapsulating the dirstate's contents.
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1186
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1187 The dirstate contains the following state:
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1188
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1189 - `identity` is the identity of the dirstate file, which can be used to
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1190 detect when changes have occurred to the dirstate file.
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1191
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1192 - `parents` is a pair containing the parents of the working copy. The
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1193 parents are updated by calling `setparents`.
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1194
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1195 - the state map maps filenames to tuples of (state, mode, size, mtime),
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1196 where state is a single character representing 'normal', 'added',
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1197 'removed', or 'merged'. It is read by treating the dirstate as a
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1198 dict. File state is updated by calling the `addfile`, `removefile` and
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1199 `dropfile` methods.
35078 a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1200
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1201 - `copymap` maps destination filenames to their source filename.
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1202
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1203 The dirstate also provides the following views onto the state:
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1204
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1205 - `nonnormalset` is a set of the filenames that have state other
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1206 than 'normal', or are normal but have an mtime of -1 ('normallookup').
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1207
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1208 - `otherparentset` is a set of the filenames that are marked as coming
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1209 from the second parent when the dirstate is currently being merged.
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1210
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1211 - `dirs` is a set-like object containing all the directories that contain
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1212 files in the dirstate, excluding any files that are marked as removed.
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1213
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1214 - `filefoldmap` is a dict mapping normalized filenames to the denormalized
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1215 form that they appear as in the dirstate.
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1216
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1217 - `dirfoldmap` is a dict mapping normalized directory names to the
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1218 denormalized form that they appear as in the dirstate.
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1219
35080 19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1220 Once instantiated, the dirs, filefoldmap and dirfoldmap views must be
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1221 maintained by the caller.
35078 a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1222 """
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1223
34337 c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1224 def __init__(self, ui, opener, root):
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1225 self._ui = ui
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1226 self._opener = opener
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1227 self._root = root
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1228 self._filename = 'dirstate'
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1229
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1230 self._parents = None
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1231 self._dirtyparents = False
34332 b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1232
34337 c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1233 # for consistent view between _pl() and _read() invocations
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1234 self._pendingmode = None
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1235
34934 6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1236 @propertycache
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1237 def _map(self):
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1238 self._map = {}
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1239 self.read()
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1240 return self._map
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1241
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1242 @propertycache
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1243 def copymap(self):
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1244 self.copymap = {}
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1245 self._map
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1246 return self.copymap
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1247
34933 0217f75b6e59 dirstate: move clear onto dirstatemap class Durham Goode <durham@fb.com> parents: 34678 diff changeset	1248 def clear(self):
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1249 self._map.clear()
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1250 self.copymap.clear()
34933 0217f75b6e59 dirstate: move clear onto dirstatemap class Durham Goode <durham@fb.com> parents: 34678 diff changeset	1251 self.setparents(nullid, nullid)
35015 ecede5263adb dirstate: clear map cached properties when clearing the map Mark Thomas <mbthomas@fb.com> parents: 34940 diff changeset	1252 util.clearcachedproperty(self, "dirs")
ecede5263adb dirstate: clear map cached properties when clearing the map Mark Thomas <mbthomas@fb.com> parents: 34940 diff changeset	1253 util.clearcachedproperty(self, "filefoldmap")
ecede5263adb dirstate: clear map cached properties when clearing the map Mark Thomas <mbthomas@fb.com> parents: 34940 diff changeset	1254 util.clearcachedproperty(self, "dirfoldmap")
ecede5263adb dirstate: clear map cached properties when clearing the map Mark Thomas <mbthomas@fb.com> parents: 34940 diff changeset	1255 util.clearcachedproperty(self, "nonnormalset")
ecede5263adb dirstate: clear map cached properties when clearing the map Mark Thomas <mbthomas@fb.com> parents: 34940 diff changeset	1256 util.clearcachedproperty(self, "otherparentset")
34933 0217f75b6e59 dirstate: move clear onto dirstatemap class Durham Goode <durham@fb.com> parents: 34678 diff changeset	1257
34332 b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1258 def iteritems(self):
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1259 return self._map.iteritems()
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1260
34408 7d2f71b7bc31 dirstate: implement __len__ on dirstatemap (issue5695) Simon Whitaker <swhitaker@fb.com> parents: 34339 diff changeset	1261 def __len__(self):
7d2f71b7bc31 dirstate: implement __len__ on dirstatemap (issue5695) Simon Whitaker <swhitaker@fb.com> parents: 34339 diff changeset	1262 return len(self._map)
7d2f71b7bc31 dirstate: implement __len__ on dirstatemap (issue5695) Simon Whitaker <swhitaker@fb.com> parents: 34339 diff changeset	1263
34332 b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1264 def __iter__(self):
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1265 return iter(self._map)
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1266
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1267 def get(self, key, default=None):
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1268 return self._map.get(key, default)
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1269
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1270 def __contains__(self, key):
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1271 return key in self._map
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1272
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1273 def __getitem__(self, key):
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1274 return self._map[key]
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1275
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1276 def keys(self):
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1277 return self._map.keys()
34333 4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1278
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1279 def preload(self):
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1280 """Loads the underlying data, if it's not already loaded"""
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1281 self._map
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1282
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1283 def addfile(self, f, state, mode, size, mtime):
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1284 """Add a tracked file to the dirstate."""
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1285 self._map[f] = dirstatetuple(state, mode, size, mtime)
35080 19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1286 if state != 'n' or mtime == -1:
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1287 self.nonnormalset.add(f)
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1288 if size == -2:
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1289 self.otherparentset.add(f)
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1290
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1291 def removefile(self, f, size):
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1292 """
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1293 Mark a file as removed in the dirstate.
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1294
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1295 The `size` parameter is used to store sentinel values that indicate
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1296 the file's previous state. In the future, we should refactor this
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1297 to be more explicit about what that state is.
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1298 """
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1299 self._map[f] = dirstatetuple('r', 0, size, 0)
35080 19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1300 self.nonnormalset.add(f)
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1301
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1302 def dropfile(self, f):
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1303 """
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1304 Remove a file from the dirstate. Returns True if the file was
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1305 previously recorded.
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1306 """
35080 19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1307 exists = self._map.pop(f, None) is not None
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1308 self.nonnormalset.discard(f)
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1309 return exists
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1310
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1311 def clearambiguoustimes(self, files, now):
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1312 for f in files:
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1313 e = self.get(f)
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1314 if e is not None and e[0] == 'n' and e[3] == now:
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1315 self._map[f] = dirstatetuple(e[0], e[1], e[2], -1)
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1316 self.nonnormalset.add(f)
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1317
34333 4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1318 def nonnormalentries(self):
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1319 '''Compute the nonnormal dirstate entries from the dmap'''
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1320 try:
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1321 return parsers.nonnormalotherparententries(self._map)
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1322 except AttributeError:
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1323 nonnorm = set()
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1324 otherparent = set()
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1325 for fname, e in self._map.iteritems():
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1326 if e[0] != 'n' or e[3] == -1:
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1327 nonnorm.add(fname)
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1328 if e[0] == 'n' and e[2] == -2:
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1329 otherparent.add(fname)
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1330 return nonnorm, otherparent
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1331
34676 bfddc3d678ae dirstate: remove _filefoldmap property cache Durham Goode <durham@fb.com> parents: 34675 diff changeset	1332 @propertycache
34334 d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1333 def filefoldmap(self):
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1334 """Returns a dictionary mapping normalized case paths to their
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1335 non-normalized versions.
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1336 """
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1337 try:
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1338 makefilefoldmap = parsers.make_file_foldmap
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1339 except AttributeError:
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1340 pass
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1341 else:
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1342 return makefilefoldmap(self._map, util.normcasespec,
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1343 util.normcasefallback)
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1344
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1345 f = {}
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1346 normcase = util.normcase
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1347 for name, s in self._map.iteritems():
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1348 if s[0] != 'r':
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1349 f[normcase(name)] = name
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1350 f['.'] = '.' # prevents useless util.fspath() invocation
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1351 return f
34335 af9722412ac3 dirstate: move _dirs to dirstatemap Durham Goode <durham@fb.com> parents: 34334 diff changeset	1352
34677 014bd2a555c8 dirstate: remove _dirs property cache Durham Goode <durham@fb.com> parents: 34676 diff changeset	1353 @propertycache
34335 af9722412ac3 dirstate: move _dirs to dirstatemap Durham Goode <durham@fb.com> parents: 34334 diff changeset	1354 def dirs(self):
af9722412ac3 dirstate: move _dirs to dirstatemap Durham Goode <durham@fb.com> parents: 34334 diff changeset	1355 """Returns a set-like object containing all the directories in the
af9722412ac3 dirstate: move _dirs to dirstatemap Durham Goode <durham@fb.com> parents: 34334 diff changeset	1356 current dirstate.
af9722412ac3 dirstate: move _dirs to dirstatemap Durham Goode <durham@fb.com> parents: 34334 diff changeset	1357 """
af9722412ac3 dirstate: move _dirs to dirstatemap Durham Goode <durham@fb.com> parents: 34334 diff changeset	1358 return util.dirs(self._map, 'r')
34337 c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1359
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1360 def _opendirstatefile(self):
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1361 fp, mode = txnutil.trypending(self._root, self._opener, self._filename)
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1362 if self._pendingmode is not None and self._pendingmode != mode:
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1363 fp.close()
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1364 raise error.Abort(_('working directory state may be '
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1365 'changed parallelly'))
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1366 self._pendingmode = mode
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1367 return fp
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1368
34338 0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class Durham Goode <durham@fb.com> parents: 34337 diff changeset	1369 def parents(self):
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1370 if not self._parents:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1371 try:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1372 fp = self._opendirstatefile()
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1373 st = fp.read(40)
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1374 fp.close()
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1375 except IOError as err:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1376 if err.errno != errno.ENOENT:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1377 raise
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1378 # File doesn't exist, so the current state is empty
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1379 st = ''
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1380
34338 0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class Durham Goode <durham@fb.com> parents: 34337 diff changeset	1381 l = len(st)
0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class Durham Goode <durham@fb.com> parents: 34337 diff changeset	1382 if l == 40:
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1383 self._parents = st[:20], st[20:40]
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1384 elif l == 0:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1385 self._parents = [nullid, nullid]
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1386 else:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1387 raise error.Abort(_('working directory state appears '
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1388 'damaged!'))
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1389
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1390 return self._parents
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1391
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1392 def setparents(self, p1, p2):
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1393 self._parents = (p1, p2)
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1394 self._dirtyparents = True
34672 e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1395
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1396 def read(self):
34675 c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	1397 # ignore HG_PENDING because identity is used only for writing
c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	1398 self.identity = util.filestat.frompath(
c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	1399 self._opener.join(self._filename))
c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	1400
34672 e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1401 try:
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1402 fp = self._opendirstatefile()
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1403 try:
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1404 st = fp.read()
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1405 finally:
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1406 fp.close()
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1407 except IOError as err:
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1408 if err.errno != errno.ENOENT:
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1409 raise
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1410 return
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1411 if not st:
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1412 return
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1413
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1414 if util.safehasattr(parsers, 'dict_new_presized'):
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1415 # Make an estimate of the number of files in the dirstate based on
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1416 # its size. From a linear regression on a set of real-world repos,
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1417 # all over 10,000 files, the size of a dirstate entry is 85
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1418 # bytes. The cost of resizing is significantly higher than the cost
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1419 # of filling in a larger presized dict, so subtract 20% from the
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1420 # size.
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1421 #
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1422 # This heuristic is imperfect in many ways, so in a future dirstate
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1423 # format update it makes sense to just record the number of entries
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1424 # on write.
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1425 self._map = parsers.dict_new_presized(len(st) / 71)
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1426
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1427 # Python's garbage collector triggers a GC each time a certain number
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1428 # of container objects (the number being defined by
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1429 # gc.get_threshold()) are allocated. parse_dirstate creates a tuple
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1430 # for each file in the dirstate. The C version then immediately marks
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1431 # them as not to be tracked by the collector. However, this has no
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1432 # effect on when GCs are triggered, only on what objects the GC looks
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1433 # into. This means that O(number of files) GCs are unavoidable.
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1434 # Depending on when in the process's lifetime the dirstate is parsed,
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1435 # this can get very expensive. As a workaround, disable GC while
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1436 # parsing the dirstate.
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1437 #
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1438 # (we cannot decorate the function directly since it is in a C module)
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1439 parse_dirstate = util.nogc(parsers.parse_dirstate)
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1440 p = parse_dirstate(self._map, self.copymap, st)
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1441 if not self._dirtyparents:
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1442 self.setparents(*p)
34673 e2214632c3a2 dirstate: move write into dirstatemap Durham Goode <durham@fb.com> parents: 34672 diff changeset	1443
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1444 # Avoid excess attribute lookups by fast pathing certain checks
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1445 self.__contains__ = self._map.__contains__
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1446 self.__getitem__ = self._map.__getitem__
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1447 self.get = self._map.get
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1448
34673 e2214632c3a2 dirstate: move write into dirstatemap Durham Goode <durham@fb.com> parents: 34672 diff changeset	1449 def write(self, st, now):
e2214632c3a2 dirstate: move write into dirstatemap Durham Goode <durham@fb.com> parents: 34672 diff changeset	1450 st.write(parsers.pack_dirstate(self._map, self.copymap,
e2214632c3a2 dirstate: move write into dirstatemap Durham Goode <durham@fb.com> parents: 34672 diff changeset	1451 self.parents(), now))
e2214632c3a2 dirstate: move write into dirstatemap Durham Goode <durham@fb.com> parents: 34672 diff changeset	1452 st.close()
e2214632c3a2 dirstate: move write into dirstatemap Durham Goode <durham@fb.com> parents: 34672 diff changeset	1453 self._dirtyparents = False
34674 60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1454 self.nonnormalset, self.otherparentset = self.nonnormalentries()
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1455
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1456 @propertycache
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1457 def nonnormalset(self):
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1458 nonnorm, otherparents = self.nonnormalentries()
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1459 self.otherparentset = otherparents
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1460 return nonnorm
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1461
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1462 @propertycache
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1463 def otherparentset(self):
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1464 nonnorm, otherparents = self.nonnormalentries()
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1465 self.nonnormalset = nonnorm
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1466 return otherparents
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1467
34675 c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	1468 @propertycache
c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	1469 def identity(self):
34934 6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1470 self._map
34675 c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	1471 return self.identity
c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	1472
34678 e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	1473 @propertycache
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	1474 def dirfoldmap(self):
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	1475 f = {}
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	1476 normcase = util.normcase
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	1477 for name in self.dirs:
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	1478 f[normcase(name)] = name
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	1479 return f

Mercurial > public > mercurial-scm > hg

annotate mercurial/dirstate.py @ 35080:19b75779b7c3