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

annotate mercurial/dirstate.py @ 48290:91f07430db8c

dirstate: use a single closure for get_flags The previous code was overlooking fallback when neither symlink not exec was supported. The number of "variants" is getting too high, so I am consolidating this in a single closure that should be easier to maintains. This also ensure that fallback flags are always taken into account. (they are not user code yet, but small experimentation shown that the feature was working as intended.) A a small side effect we need to check for symlink support more lazily and this show up in the test in a couple of places. Differential Revision: https://phab.mercurial-scm.org/D11728

author	Pierre-Yves David <pierre-yves.david@octobus.net>
date	Thu, 28 Oct 2021 17:26:03 +0200
parents	0d6a099bba58
children	500260410bb8

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 #
46819 d4ba4d51f85f contributor: change mentions of mpm to olivia Rapha?l Gom?s <rgomes@octobus.net> parents: 46796 diff changeset	3 # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
8226 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
32385 73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32248 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 _
43090 1f339b503a40 py3: manually import pycompat.delattr where it is needed Gregory Szorc <gregory.szorc@gmail.com> parents: 43077 diff changeset	17 from .pycompat import delattr
43239 6fcdcea2b03a dirstate: add some traces on listdir calls Augie Fackler <augie@google.com> parents: 43117 diff changeset	18
6fcdcea2b03a dirstate: add some traces on listdir calls Augie Fackler <augie@google.com> parents: 43117 diff changeset	19 from hgdemandimport import tracing
6fcdcea2b03a dirstate: add some traces on listdir calls Augie Fackler <augie@google.com> parents: 43117 diff changeset	20
27503 0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	21 from . import (
47506 8b7e47802deb dirstate: split dirstatemap in its own file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47494 diff changeset	22 dirstatemap,
27503 0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	23 encoding,
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	24 error,
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	25 match as matchmod,
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	26 pathutil,
32411 df448de7cf3b parsers: switch to policy importer Yuya Nishihara <yuya@tcha.org> parents: 32391 diff changeset	27 policy,
30317 ba2c04059317 py3: use pycompat.ossep at certain places Pulkit Goyal <7895pulkit@gmail.com> parents: 30224 diff changeset	28 pycompat,
27503 0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	29 scmutil,
44540 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	30 sparse,
27503 0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	31 util,
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	32 )
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	33
48271 269ff8978086 dirstate: store mtimes with nanosecond precision in memory Simon Sapin <simon.sapin@octobus.net> parents: 48263 diff changeset	34 from .dirstateutils import (
269ff8978086 dirstate: store mtimes with nanosecond precision in memory Simon Sapin <simon.sapin@octobus.net> parents: 48263 diff changeset	35 timestamp,
269ff8978086 dirstate: store mtimes with nanosecond precision in memory Simon Sapin <simon.sapin@octobus.net> parents: 48263 diff changeset	36 )
269ff8978086 dirstate: store mtimes with nanosecond precision in memory Simon Sapin <simon.sapin@octobus.net> parents: 48263 diff changeset	37
42931 d459cd8ea42d interfaces: introduce an interface for dirstate implementations Augie Fackler <augie@google.com> parents: 42771 diff changeset	38 from .interfaces import (
d459cd8ea42d interfaces: introduce an interface for dirstate implementations Augie Fackler <augie@google.com> parents: 42771 diff changeset	39 dirstate as intdirstate,
d459cd8ea42d interfaces: introduce an interface for dirstate implementations Augie Fackler <augie@google.com> parents: 42771 diff changeset	40 util as interfaceutil,
d459cd8ea42d interfaces: introduce an interface for dirstate implementations Augie Fackler <augie@google.com> parents: 42771 diff changeset	41 )
d459cd8ea42d interfaces: introduce an interface for dirstate implementations Augie Fackler <augie@google.com> parents: 42771 diff changeset	42
43554 9f70512ae2cf cleanup: remove pointless r-prefixes on single-quoted strings Augie Fackler <augie@google.com> parents: 43553 diff changeset	43 parsers = policy.importmod('parsers')
9f70512ae2cf cleanup: remove pointless r-prefixes on single-quoted strings Augie Fackler <augie@google.com> parents: 43553 diff changeset	44 rustmod = policy.importrust('dirstate')
32411 df448de7cf3b parsers: switch to policy importer Yuya Nishihara <yuya@tcha.org> parents: 32391 diff changeset	45
48247 5c567aca080d dirstate-v2: add an option to prevent unintentional slow dirstate-v2 Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48235 diff changeset	46 HAS_FAST_DIRSTATE_V2 = rustmod is not None
5c567aca080d dirstate-v2: add an option to prevent unintentional slow dirstate-v2 Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48235 diff changeset	47
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	48 propertycache = util.propertycache
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	49 filecache = scmutil.filecache
47521 abed645b8e96 dirstate: move the handling of special case within the dirstatemap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47517 diff changeset	50 _rangemask = dirstatemap.rangemask
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	51
48059 d5528ac9b4f2 dirstate: Use the Rust implementation of DirstateItem when Rust is enabled Simon Sapin <simon.sapin@octobus.net> parents: 48041 diff changeset	52 DirstateItem = dirstatemap.DirstateItem
21808 7537e57f5dbd dirstate: add dirstatetuple to create dirstate values Siddharth Agarwal <sid0@fb.com> parents: 21116 diff changeset	53
47487 cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47486 diff changeset	54
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	55 class repocache(filecache):
fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	56 """filecache for files in .hg/"""
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	57
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	58 def join(self, obj, fname):
fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	59 return obj._opener.join(fname)
4610 274c99fc629f dirstate: simplify state() Matt Mackall <mpm@selenic.com> parents: 4609 diff changeset	60
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	61
16202 53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	62 class rootcache(filecache):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	63 """filecache for files in the repository root"""
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	64
16202 53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	65 def join(self, obj, fname):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	66 return obj._join(fname)
53e2cd303ecf dirstate: filecacheify _ignore (issue3278) Idan Kamara <idankk86@gmail.com> parents: 16201 diff changeset	67
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	68
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	69 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	70 '''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	71 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	72 try:
48271 269ff8978086 dirstate: store mtimes with nanosecond precision in memory Simon Sapin <simon.sapin@octobus.net> parents: 48263 diff changeset	73 return timestamp.mtime_of(os.fstat(tmpfd))
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	74 finally:
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	75 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	76 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	77
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	78
47592 0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	79 def requires_parents_change(func):
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	80 def wrap(self, args, *kwargs):
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	81 if not self.pendingparentchange():
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	82 msg = 'calling `%s` outside of a parentchange context'
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	83 msg %= func.__name__
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	84 raise error.ProgrammingError(msg)
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	85 return func(self, args, *kwargs)
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	86
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	87 return wrap
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	88
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	89
47593 f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	90 def requires_no_parents_change(func):
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	91 def wrap(self, args, *kwargs):
47594 0cef28b121a4 context: use `dirstate.set_tracked` in `context.add` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47593 diff changeset	92 if self.pendingparentchange():
47593 f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	93 msg = 'calling `%s` inside of a parentchange context'
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	94 msg %= func.__name__
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	95 raise error.ProgrammingError(msg)
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	96 return func(self, args, *kwargs)
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	97
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	98 return wrap
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	99
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	100
42931 d459cd8ea42d interfaces: introduce an interface for dirstate implementations Augie Fackler <augie@google.com> parents: 42771 diff changeset	101 @interfaceutil.implementer(intdirstate.idirstate)
1559 59b3639df0a9 Convert all classes to new-style classes by deriving them from object. Eric Hopper <hopper@omnifarious.org> parents: 1541 diff changeset	102 class dirstate(object):
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 45957 diff changeset	103 def __init__(
47291 1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47288 diff changeset	104 self,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47288 diff changeset	105 opener,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47288 diff changeset	106 ui,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47288 diff changeset	107 root,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47288 diff changeset	108 validate,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47288 diff changeset	109 sparsematchfn,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47288 diff changeset	110 nodeconstants,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47288 diff changeset	111 use_dirstate_v2,
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 45957 diff changeset	112 ):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	113 """Create a new dirstate object.
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	114
aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	115 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	116 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	117 the dirstate.
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	118 """
47291 1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47288 diff changeset	119 self._use_dirstate_v2 = use_dirstate_v2
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 45957 diff changeset	120 self._nodeconstants = nodeconstants
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	121 self._opener = opener
13032 e41e2b79883d dirstate: warn on invalid parents rather than aborting Matt Mackall <mpm@selenic.com> parents: 12907 diff changeset	122 self._validate = validate
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	123 self._root = root
33373 fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	124 self._sparsematchfn = sparsematchfn
24198 3cc630be5f09 dirstate: make sure rootdir ends with directory separator (issue4557) Yuya Nishihara <yuya@tcha.org> parents: 23866 diff changeset	125 # 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	126 # 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	127 self._rootdir = pathutil.normasprefix(root)
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	128 self._dirty = False
48271 269ff8978086 dirstate: store mtimes with nanosecond precision in memory Simon Sapin <simon.sapin@octobus.net> parents: 48263 diff changeset	129 self._lastnormaltime = timestamp.zero()
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	130 self._ui = ui
16200 9d4a2942a732 dirstate: add filecache support Idan Kamara <idankk86@gmail.com> parents: 16143 diff changeset	131 self._filecache = {}
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	132 self._parentwriters = 0
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	133 self._filename = b'dirstate'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	134 self._pendingfilename = b'%s.pending' % self._filename
29783 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	135 self._plchangecallbacks = {}
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	136 self._origpl = None
47506 8b7e47802deb dirstate: split dirstatemap in its own file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47494 diff changeset	137 self._mapcls = dirstatemap.dirstatemap
41685 e178b131906a dirstate: call and cache os.getcwd() in constructor Martin von Zweigbergk <martinvonz@google.com> parents: 40493 diff changeset	138 # Access and cache cwd early, so we don't access it for the first time
e178b131906a dirstate: call and cache os.getcwd() in constructor Martin von Zweigbergk <martinvonz@google.com> parents: 40493 diff changeset	139 # after a working-copy update caused it to not exist (accessing it then
e178b131906a dirstate: call and cache os.getcwd() in constructor Martin von Zweigbergk <martinvonz@google.com> parents: 40493 diff changeset	140 # raises an exception).
e178b131906a dirstate: call and cache os.getcwd() in constructor Martin von Zweigbergk <martinvonz@google.com> parents: 40493 diff changeset	141 self._cwd
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	142
44780 35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44779 diff changeset	143 def prefetch_parents(self):
35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44779 diff changeset	144 """make sure the parents are loaded
35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44779 diff changeset	145
35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44779 diff changeset	146 Used to avoid a race condition.
35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44779 diff changeset	147 """
35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44779 diff changeset	148 self._pl
35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44779 diff changeset	149
32385 73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32248 diff changeset	150 @contextlib.contextmanager
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32248 diff changeset	151 def parentchange(self):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	152 """Context manager for handling dirstate parents.
32385 73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32248 diff changeset	153
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32248 diff changeset	154 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: 32248 diff changeset	155 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: 32248 diff changeset	156 released.
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	157 """
32385 73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32248 diff changeset	158 self._parentwriters += 1
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32248 diff changeset	159 yield
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32248 diff changeset	160 # 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: 32248 diff changeset	161 # 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: 32248 diff changeset	162 # 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: 32248 diff changeset	163 # 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: 32248 diff changeset	164 # 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: 32248 diff changeset	165 self._parentwriters -= 1
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32248 diff changeset	166
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	167 def pendingparentchange(self):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	168 """Returns true if the dirstate is in the middle of a set of changes
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	169 that modify the dirstate parent.
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	170 """
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	171 return self._parentwriters > 0
723 9e0f3ba4a9c2 Work on walk code. Bryan O'Sullivan <bos@serpentine.com> parents: 705 diff changeset	172
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	173 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	174 def _map(self):
35101 a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35055 diff changeset	175 """Return the dirstate contents (see documentation for dirstatemap)."""
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 45957 diff changeset	176 self._map = self._mapcls(
47291 1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47288 diff changeset	177 self._ui,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47288 diff changeset	178 self._opener,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47288 diff changeset	179 self._root,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47288 diff changeset	180 self._nodeconstants,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47288 diff changeset	181 self._use_dirstate_v2,
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 45957 diff changeset	182 )
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	183 return self._map
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	184
33373 fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	185 @property
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	186 def _sparsematcher(self):
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	187 """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	188
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	189 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	190 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	191 included in the working directory.
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	192 """
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	193 # 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	194 # 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	195 # 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	196 return self._sparsematchfn()
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	197
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	198 @repocache(b'branch')
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	199 def _branch(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	200 try:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	201 return self._opener.read(b"branch").strip() or b"default"
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25658 diff changeset	202 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	203 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	204 raise
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	205 return b"default"
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	206
34346 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34345 diff changeset	207 @property
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	208 def _pl(self):
34345 0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class Durham Goode <durham@fb.com> parents: 34344 diff changeset	209 return self._map.parents()
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	210
35107 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35106 diff changeset	211 def hasdir(self, d):
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35106 diff changeset	212 return self._map.hastrackeddir(d)
16143 fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15801 diff changeset	213
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	214 @rootcache(b'.hgignore')
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	215 def _ignore(self):
27594 0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	216 files = self._ignorefiles()
25216 dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25163 diff changeset	217 if not files:
41687 0531dff73d0b match: delete unused root and cwd arguments from {always,never,exact}() (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41685 diff changeset	218 return matchmod.never()
25216 dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25163 diff changeset	219
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	220 pats = [b'include:%s' % f for f in files]
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	221 return matchmod.match(self._root, b'', [], pats, warn=self._ui.warn)
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	222
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	223 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	224 def _slash(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	225 return self._ui.configbool(b'ui', b'slash') and pycompat.ossep != b'/'
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	226
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	227 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	228 def _checklink(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	229 return util.checklink(self._root)
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	230
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	231 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	232 def _checkexec(self):
44878 373dd22ae60e dirstate: force _checkexec to return a bool Mitchell Plamann <mplamann@janestreet.com> parents: 44540 diff changeset	233 return bool(util.checkexec(self._root))
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	234
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	235 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	236 def _checkcase(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	237 return not util.fscasesensitive(self._join(b'.hg'))
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	238
4905 fc61495ea9cf dirstate: make wjoin function private Matt Mackall <mpm@selenic.com> parents: 4904 diff changeset	239 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	240 # 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	241 # 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	242 return self._rootdir + f
723 9e0f3ba4a9c2 Work on walk code. Bryan O'Sullivan <bos@serpentine.com> parents: 705 diff changeset	243
15337 cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	244 def flagfunc(self, buildfallback):
48290 91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	245 """build a callable that returns flags associated with a filename
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	246
48290 91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	247 The information is extracted from three possible layers:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	248 1. the file system if it supports the information
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	249 2. the "fallback" information stored in the dirstate if any
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	250 3. a more expensive mechanism inferring the flags from the parents.
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	251 """
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	252
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	253 # small hack to cache the result of buildfallback()
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	254 fallback_func = []
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	255
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	256 def get_flags(x):
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	257 entry = None
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	258 fallback_value = None
48286 0d6a099bba58 dirstate: group return logic and clarify each function in flagfunc Rapha?l Gom?s <rgomes@octobus.net> parents: 48285 diff changeset	259 try:
0d6a099bba58 dirstate: group return logic and clarify each function in flagfunc Rapha?l Gom?s <rgomes@octobus.net> parents: 48285 diff changeset	260 st = os.lstat(self._join(x))
48290 91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	261 except OSError:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	262 return b''
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	263
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	264 if self._checklink:
48286 0d6a099bba58 dirstate: group return logic and clarify each function in flagfunc Rapha?l Gom?s <rgomes@octobus.net> parents: 48285 diff changeset	265 if util.statislink(st):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	266 return b'l'
48290 91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	267 else:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	268 entry = self.get_entry(x)
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	269 if entry.has_fallback_symlink:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	270 if entry.fallback_symlink:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	271 return b'l'
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	272 else:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	273 if not fallback_func:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	274 fallback_func.append(buildfallback())
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	275 fallback_value = fallback_func[0](x)
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	276 if b'l' in fallback_value:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	277 return b'l'
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	278
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	279 if self._checkexec:
48286 0d6a099bba58 dirstate: group return logic and clarify each function in flagfunc Rapha?l Gom?s <rgomes@octobus.net> parents: 48285 diff changeset	280 if util.statisexec(st):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	281 return b'x'
48290 91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	282 else:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	283 if entry is None:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	284 entry = self.get_entry(x)
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	285 if entry.has_fallback_exec:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	286 if entry.fallback_exec:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	287 return b'x'
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	288 else:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	289 if fallback_value is None:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	290 if not fallback_func:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	291 fallback_func.append(buildfallback())
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	292 fallback_value = fallback_func[0](x)
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	293 if b'x' in fallback_value:
91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	294 return b'x'
48286 0d6a099bba58 dirstate: group return logic and clarify each function in flagfunc Rapha?l Gom?s <rgomes@octobus.net> parents: 48285 diff changeset	295 return b''
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	296
48290 91f07430db8c dirstate: use a single closure for get_flags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48286 diff changeset	297 return get_flags
48285 8f54d9c79b12 dirstate: add missing return on platforms without exec or symlink Rapha?l Gom?s <rgomes@octobus.net> parents: 48271 diff changeset	298
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	299 @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	300 def _cwd(self):
33215 b7f6885cb055 dirstate: centralize _cwd handling into _cwd method FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32792 diff changeset	301 # internal config: ui.forcecwd
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	302 forcecwd = self._ui.config(b'ui', b'forcecwd')
33215 b7f6885cb055 dirstate: centralize _cwd handling into _cwd method FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32792 diff changeset	303 if forcecwd:
b7f6885cb055 dirstate: centralize _cwd handling into _cwd method FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32792 diff changeset	304 return forcecwd
39823 24e493ec2229 py3: rename pycompat.getcwd() to encoding.getcwd() (API) Matt Harbison <matt_harbison@yahoo.com> parents: 39471 diff changeset	305 return encoding.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	306
870 a82eae840447 Teach walk code about absolute paths. Bryan O'Sullivan <bos@serpentine.com> parents: 839 diff changeset	307 def getcwd(self):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	308 """Return the path from which a canonical path is calculated.
26293 3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path Yuya Nishihara <yuya@tcha.org> parents: 25877 diff changeset	309
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path Yuya Nishihara <yuya@tcha.org> parents: 25877 diff changeset	310 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	311 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	312 used to get real file paths. Use vfs functions instead.
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	313 """
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	314 cwd = self._cwd
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	315 if cwd == self._root:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	316 return b''
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	317 # 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	318 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	319 if not util.endswithsep(rootsep):
30619 cfe66dcf45c0 py3: replace os.sep with pycompat.ossep (part 2 of 4) Pulkit Goyal <7895pulkit@gmail.com> parents: 30528 diff changeset	320 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	321 if cwd.startswith(rootsep):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	322 return cwd[len(rootsep) :]
4230 c93562fb12cc Fix handling of paths when run outside the repo. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4229 diff changeset	323 else:
c93562fb12cc Fix handling of paths when run outside the repo. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4229 diff changeset	324 # 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	325 return cwd
870 a82eae840447 Teach walk code about absolute paths. Bryan O'Sullivan <bos@serpentine.com> parents: 839 diff changeset	326
4525 78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	327 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	328 if cwd is None:
78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	329 cwd = self.getcwd()
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	330 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	331 if self._slash:
19210 865beb849720 dirstate: don't overnormalize for ui.slash Matt Mackall <mpm@selenic.com> parents: 19128 diff changeset	332 return util.pconvert(path)
4527 b422b558015b Add ui.slash hgrc setting Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4525 diff changeset	333 return path
4525 78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	334
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	335 def __getitem__(self, key):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	336 """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	337
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	338 States are:
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	339 n normal
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	340 m needs merging
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	341 r marked for removal
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	342 a marked for addition
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	343 ? not tracked
47512 769037a279ec dirstate-entry: add a `state` property (and use it) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47511 diff changeset	344
769037a279ec dirstate-entry: add a `state` property (and use it) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47511 diff changeset	345 XXX The "state" is a bit obscure to be in the "public" API. we should
769037a279ec dirstate-entry: add a `state` property (and use it) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47511 diff changeset	346 consider migrating all user of this to going through the dirstate entry
769037a279ec dirstate-entry: add a `state` property (and use it) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47511 diff changeset	347 instead.
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	348 """
48119 dcd97b082b3b dirstate: deprecate `__getitem__` access Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48101 diff changeset	349 msg = b"don't use dirstate[file], use dirstate.get_entry(file)"
dcd97b082b3b dirstate: deprecate `__getitem__` access Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48101 diff changeset	350 util.nouideprecwarn(msg, b'6.1', stacklevel=2)
47512 769037a279ec dirstate-entry: add a `state` property (and use it) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47511 diff changeset	351 entry = self._map.get(key)
769037a279ec dirstate-entry: add a `state` property (and use it) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47511 diff changeset	352 if entry is not None:
769037a279ec dirstate-entry: add a `state` property (and use it) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47511 diff changeset	353 return entry.state
769037a279ec dirstate-entry: add a `state` property (and use it) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47511 diff changeset	354 return b'?'
220 3113a94c1bff change dircache into dirstate mpm@selenic.com parents: 217 diff changeset	355
48097 6a78715e56c8 dirstate: add a `get_entry` method to the dirstate Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48074 diff changeset	356 def get_entry(self, path):
6a78715e56c8 dirstate: add a `get_entry` method to the dirstate Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48074 diff changeset	357 """return a DirstateItem for the associated path"""
6a78715e56c8 dirstate: add a `get_entry` method to the dirstate Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48074 diff changeset	358 entry = self._map.get(path)
6a78715e56c8 dirstate: add a `get_entry` method to the dirstate Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48074 diff changeset	359 if entry is None:
6a78715e56c8 dirstate: add a `get_entry` method to the dirstate Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48074 diff changeset	360 return DirstateItem()
6a78715e56c8 dirstate: add a `get_entry` method to the dirstate Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48074 diff changeset	361 return entry
6a78715e56c8 dirstate: add a `get_entry` method to the dirstate Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48074 diff changeset	362
220 3113a94c1bff change dircache into dirstate mpm@selenic.com parents: 217 diff changeset	363 def __contains__(self, key):
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	364 return key in self._map
a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	365
a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	366 def __iter__(self):
33733 36d216dcae6a dirstate: simplify dirstate's __iter__ Alex Gaynor <agaynor@mozilla.com> parents: 33440 diff changeset	367 return iter(sorted(self._map))
220 3113a94c1bff change dircache into dirstate mpm@selenic.com parents: 217 diff changeset	368
32583 b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32411 diff changeset	369 def items(self):
43106 d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43090 diff changeset	370 return pycompat.iteritems(self._map)
18792 10669e24eb6c completion: add a debugpathcomplete command Bryan O'Sullivan <bryano@fb.com> parents: 18760 diff changeset	371
32583 b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32411 diff changeset	372 iteritems = items
b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32411 diff changeset	373
227 f57519cddd3d move repo.current to dirstate.parents() mpm@selenic.com parents: 225 diff changeset	374 def parents(self):
13032 e41e2b79883d dirstate: warn on invalid parents rather than aborting Matt Mackall <mpm@selenic.com> parents: 12907 diff changeset	375 return [self._validate(p) for p in self._pl]
227 f57519cddd3d move repo.current to dirstate.parents() mpm@selenic.com parents: 225 diff changeset	376
13876 10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	377 def p1(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	378 return self._validate(self._pl[0])
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	379
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	380 def p2(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	381 return self._validate(self._pl[1])
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	382
47510 94c58f3aab56 dirstate: add a `in_merge` property Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47506 diff changeset	383 @property
94c58f3aab56 dirstate: add a `in_merge` property Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47506 diff changeset	384 def in_merge(self):
94c58f3aab56 dirstate: add a `in_merge` property Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47506 diff changeset	385 """True if a merge is in progress"""
94c58f3aab56 dirstate: add a `in_merge` property Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47506 diff changeset	386 return self._pl[1] != self._nodeconstants.nullid
94c58f3aab56 dirstate: add a `in_merge` property Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47506 diff changeset	387
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	388 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	389 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	390
47055 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	391 def setparents(self, p1, p2=None):
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	392 """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	393
47513 10e740292dff dirstate-entry: add a `merged` property Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47512 diff changeset	394 When moving from two parents to one, "merged" entries a
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	395 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	396 returned by the call.
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	397
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	398 See localrepo.setparents()
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	399 """
47055 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	400 if p2 is None:
d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	401 p2 = self._nodeconstants.nullid
22407 d259322a394b dirstate: add exception when calling setparent without begin/end (API) Durham Goode <durham@fb.com> parents: 22404 diff changeset	402 if self._parentwriters == 0:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	403 raise ValueError(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	404 b"cannot set dirstate parent outside of "
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	405 b"dirstate.parentchange context manager"
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	406 )
22407 d259322a394b dirstate: add exception when calling setparent without begin/end (API) Durham Goode <durham@fb.com> parents: 22404 diff changeset	407
34346 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34345 diff changeset	408 self._dirty = True
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	409 oldp2 = self._pl[1]
29783 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	410 if self._origpl is None:
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	411 self._origpl = self._pl
48011 dd267f16042f dirstate: make a conditionnal easier to read in `setparents` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48010 diff changeset	412 nullid = self._nodeconstants.nullid
48074 5d68c4eedd66 dirstate: move parent state handling in the dirstatemap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48073 diff changeset	413 # True if we need to fold p2 related state back to a linear case
5d68c4eedd66 dirstate: move parent state handling in the dirstatemap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48073 diff changeset	414 fold_p2 = oldp2 != nullid and p2 == nullid
5d68c4eedd66 dirstate: move parent state handling in the dirstatemap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48073 diff changeset	415 return self._map.setparents(p1, p2, fold_p2=fold_p2)
227 f57519cddd3d move repo.current to dirstate.parents() mpm@selenic.com parents: 225 diff changeset	416
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	417 def setbranch(self, branch):
40493 7caf632e30c3 filecache: unimplement __set__() and __delete__() (API) Yuya Nishihara <yuya@tcha.org> parents: 39823 diff changeset	418 self.__class__._branch.set(self, encoding.fromlocal(branch))
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	419 f = self._opener(b'branch', b'w', atomictemp=True, checkambig=True)
16472 14a4e17f0817 dirstate: write branch file atomically Idan Kamara <idankk86@gmail.com> parents: 16323 diff changeset	420 try:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	421 f.write(self._branch + b'\n')
16472 14a4e17f0817 dirstate: write branch file atomically Idan Kamara <idankk86@gmail.com> parents: 16323 diff changeset	422 f.close()
18317 365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	423
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	424 # 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	425 # replacing the underlying file
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	426 ce = self._filecache[b'_branch']
18317 365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	427 if ce:
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	428 ce.refresh()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	429 except: # re-raises
18076 3bc21f6daac4 dirstate: don't rename branch file if writing it failed Idan Kamara <idankk86@gmail.com> parents: 17984 diff changeset	430 f.discard()
3bc21f6daac4 dirstate: don't rename branch file if writing it failed Idan Kamara <idankk86@gmail.com> parents: 17984 diff changeset	431 raise
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	432
4613 3a645af7fb76 localrepo and dirstate: rename reload to invalidate Matt Mackall <mpm@selenic.com> parents: 4612 diff changeset	433 def invalidate(self):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	434 """Causes the next access to reread the dirstate.
32702 e696f597d02f dirstate: add docstring for invalidate Siddharth Agarwal <sid0@fb.com> parents: 32631 diff changeset	435
e696f597d02f dirstate: add docstring for invalidate Siddharth Agarwal <sid0@fb.com> parents: 32631 diff changeset	436 This is different from localrepo.invalidatedirstate() because it always
e696f597d02f dirstate: add docstring for invalidate Siddharth Agarwal <sid0@fb.com> parents: 32631 diff changeset	437 rereads the dirstate. Use localrepo.invalidatedirstate() if you want to
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	438 check whether the dirstate has changed before rereading it."""
32702 e696f597d02f dirstate: add docstring for invalidate Siddharth Agarwal <sid0@fb.com> parents: 32631 diff changeset	439
43551 313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings Augie Fackler <augie@google.com> parents: 43508 diff changeset	440 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	441 if a in self.__dict__:
6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4952 diff changeset	442 delattr(self, a)
48271 269ff8978086 dirstate: store mtimes with nanosecond precision in memory Simon Sapin <simon.sapin@octobus.net> parents: 48263 diff changeset	443 self._lastnormaltime = timestamp.zero()
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	444 self._dirty = False
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	445 self._parentwriters = 0
29783 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	446 self._origpl = None
4375 109077e7048d When reloading the dirstate, recompute ignore information if needed. Bryan O'Sullivan <bos@serpentine.com> parents: 4374 diff changeset	447
363 ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	448 def copy(self, source, dest):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	449 """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	450 if source == dest:
deda205a00e1 Ignore dummy copies in dirstate and localrepo.filecommit() Patrick Mezard <pmezard@gmail.com> parents: 6479 diff changeset	451 return
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	452 self._dirty = True
7566 5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441) Patrick Mezard <pmezard@gmail.com> parents: 7280 diff changeset	453 if source is not None:
34343 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34342 diff changeset	454 self._map.copymap[dest] = source
48072 62188e4de549 dirstate: drop the `_updatedfiles` set Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48070 diff changeset	455 else:
62188e4de549 dirstate: drop the `_updatedfiles` set Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48070 diff changeset	456 self._map.copymap.pop(dest, None)
363 ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	457
ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	458 def copied(self, file):
34343 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34342 diff changeset	459 return self._map.copymap.get(file, None)
3154 b1f10d3223c1 dirstate: add copies function Matt Mackall <mpm@selenic.com> parents: 2962 diff changeset	460
b1f10d3223c1 dirstate: add copies function Matt Mackall <mpm@selenic.com> parents: 2962 diff changeset	461 def copies(self):
34343 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34342 diff changeset	462 return self._map.copymap
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 514 diff changeset	463
47593 f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	464 @requires_no_parents_change
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	465 def set_tracked(self, filename):
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	466 """a "public" method for generic code to mark a file as tracked
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	467
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	468 This function is to be called outside of "update/merge" case. For
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	469 example by a command like `hg add X`.
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	470
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	471 return True the file was previously untracked, False otherwise.
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	472 """
48008 6255a0d33c45 dirstate: directly call the right function in `set_tracked` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48007 diff changeset	473 self._dirty = True
47593 f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	474 entry = self._map.get(filename)
48014 0d2a404f1932 dirstate: introduce a set_tracked method on "map" and "item" Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48013 diff changeset	475 if entry is None or not entry.tracked:
48008 6255a0d33c45 dirstate: directly call the right function in `set_tracked` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48007 diff changeset	476 self._check_new_tracked_filename(filename)
48014 0d2a404f1932 dirstate: introduce a set_tracked method on "map" and "item" Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48013 diff changeset	477 return self._map.set_tracked(filename)
47593 f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47592 diff changeset	478
47599 cce51119bfe6 dirstate: add a `set_untracked` method for "hg remove"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47594 diff changeset	479 @requires_no_parents_change
cce51119bfe6 dirstate: add a `set_untracked` method for "hg remove"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47594 diff changeset	480 def set_untracked(self, filename):
cce51119bfe6 dirstate: add a `set_untracked` method for "hg remove"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47594 diff changeset	481 """a "public" method for generic code to mark a file as untracked
cce51119bfe6 dirstate: add a `set_untracked` method for "hg remove"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47594 diff changeset	482
cce51119bfe6 dirstate: add a `set_untracked` method for "hg remove"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47594 diff changeset	483 This function is to be called outside of "update/merge" case. For
cce51119bfe6 dirstate: add a `set_untracked` method for "hg remove"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47594 diff changeset	484 example by a command like `hg remove X`.
cce51119bfe6 dirstate: add a `set_untracked` method for "hg remove"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47594 diff changeset	485
cce51119bfe6 dirstate: add a `set_untracked` method for "hg remove"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47594 diff changeset	486 return True the file was previously tracked, False otherwise.
cce51119bfe6 dirstate: add a `set_untracked` method for "hg remove"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47594 diff changeset	487 """
48000 5a6c1ef4bcac dirstate: make dirstatemap.set_untracked deal with added file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47999 diff changeset	488 ret = self._map.set_untracked(filename)
5a6c1ef4bcac dirstate: make dirstatemap.set_untracked deal with added file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47999 diff changeset	489 if ret:
47912 1c797757f5bb dirstate: directly call the dirstatemap in `set_untracked` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47777 diff changeset	490 self._dirty = True
48000 5a6c1ef4bcac dirstate: make dirstatemap.set_untracked deal with added file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47999 diff changeset	491 return ret
47599 cce51119bfe6 dirstate: add a `set_untracked` method for "hg remove"-like usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47594 diff changeset	492
47704 8a50fb0784a9 dirstate: introduce a `set_clean` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47701 diff changeset	493 @requires_no_parents_change
8a50fb0784a9 dirstate: introduce a `set_clean` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47701 diff changeset	494 def set_clean(self, filename, parentfiledata=None):
8a50fb0784a9 dirstate: introduce a `set_clean` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47701 diff changeset	495 """record that the current state of the file on disk is known to be clean"""
8a50fb0784a9 dirstate: introduce a `set_clean` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47701 diff changeset	496 self._dirty = True
47948 1b3c753b62c6 dirstate: drop the `_normal` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47947 diff changeset	497 if parentfiledata:
1b3c753b62c6 dirstate: drop the `_normal` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47947 diff changeset	498 (mode, size, mtime) = parentfiledata
1b3c753b62c6 dirstate: drop the `_normal` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47947 diff changeset	499 else:
1b3c753b62c6 dirstate: drop the `_normal` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47947 diff changeset	500 (mode, size, mtime) = self._get_filedata(filename)
48002 4e6f27230aee dirstate: introduce a `set_clean` method on dirstate's map and items Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48001 diff changeset	501 if not self._map[filename].tracked:
4e6f27230aee dirstate: introduce a `set_clean` method on dirstate's map and items Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48001 diff changeset	502 self._check_new_tracked_filename(filename)
4e6f27230aee dirstate: introduce a `set_clean` method on dirstate's map and items Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48001 diff changeset	503 self._map.set_clean(filename, mode, size, mtime)
47948 1b3c753b62c6 dirstate: drop the `_normal` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47947 diff changeset	504 if mtime > self._lastnormaltime:
1b3c753b62c6 dirstate: drop the `_normal` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47947 diff changeset	505 # Remember the most recent modification timeslot for status(),
1b3c753b62c6 dirstate: drop the `_normal` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47947 diff changeset	506 # to make sure we won't miss future size-preserving file content
1b3c753b62c6 dirstate: drop the `_normal` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47947 diff changeset	507 # modifications that happen within the same timeslot.
1b3c753b62c6 dirstate: drop the `_normal` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47947 diff changeset	508 self._lastnormaltime = mtime
47704 8a50fb0784a9 dirstate: introduce a `set_clean` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47701 diff changeset	509
47720 b0314d8deee1 dirstate: add a `set_possibly_dirty` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47719 diff changeset	510 @requires_no_parents_change
b0314d8deee1 dirstate: add a `set_possibly_dirty` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47719 diff changeset	511 def set_possibly_dirty(self, filename):
b0314d8deee1 dirstate: add a `set_possibly_dirty` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47719 diff changeset	512 """record that the current state of the file on disk is unknown"""
b0314d8deee1 dirstate: add a `set_possibly_dirty` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47719 diff changeset	513 self._dirty = True
b0314d8deee1 dirstate: add a `set_possibly_dirty` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47719 diff changeset	514 self._map.set_possibly_dirty(filename)
b0314d8deee1 dirstate: add a `set_possibly_dirty` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47719 diff changeset	515
47592 0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	516 @requires_parents_change
47693 46c318b9b9a4 dirstate: rename `update_file_reference` to `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47692 diff changeset	517 def update_file_p1(
47592 0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	518 self,
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	519 filename,
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	520 p1_tracked,
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	521 ):
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	522 """Set a file as tracked in the parent (or not)
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	523
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	524 This is to be called when adjust the dirstate to a new parent after an history
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	525 rewriting operation.
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	526
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	527 It should not be called during a merge (p2 != nullid) and only within
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	528 a `with dirstate.parentchange():` context.
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	529 """
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	530 if self.in_merge:
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	531 msg = b'update_file_reference should not be called when merging'
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	532 raise error.ProgrammingError(msg)
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	533 entry = self._map.get(filename)
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	534 if entry is None:
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	535 wc_tracked = False
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	536 else:
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	537 wc_tracked = entry.tracked
48152 98b3eb6c1479 dirstate: align the dirstatemap's API to the data change Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48133 diff changeset	538 if not (p1_tracked or wc_tracked):
47592 0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	539 # the file is no longer relevant to anyone
48023 bac82c2ce858 dirstate: use `reset_state` to drop file in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48019 diff changeset	540 if self._map.get(filename) is not None:
bac82c2ce858 dirstate: use `reset_state` to drop file in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48019 diff changeset	541 self._map.reset_state(filename)
48012 d459c6b84961 dirstate: inline the last two `_drop` usage Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48011 diff changeset	542 self._dirty = True
47592 0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	543 elif (not p1_tracked) and wc_tracked:
47694 1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47693 diff changeset	544 if entry is not None and entry.added:
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47693 diff changeset	545 return # avoid dropping copy information (maybe?)
47592 0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47591 diff changeset	546
47694 1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47693 diff changeset	547 parentfiledata = None
48153 42ab0bcb6ded dirstate: narrow gathering of parent data Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48152 diff changeset	548 if wc_tracked and p1_tracked:
47694 1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47693 diff changeset	549 parentfiledata = self._get_filedata(filename)
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47693 diff changeset	550
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47693 diff changeset	551 self._map.reset_state(
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47693 diff changeset	552 filename,
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47693 diff changeset	553 wc_tracked,
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47693 diff changeset	554 p1_tracked,
48152 98b3eb6c1479 dirstate: align the dirstatemap's API to the data change Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48133 diff changeset	555 # the underlying reference might have changed, we will have to
98b3eb6c1479 dirstate: align the dirstatemap's API to the data change Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48133 diff changeset	556 # check it.
98b3eb6c1479 dirstate: align the dirstatemap's API to the data change Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48133 diff changeset	557 has_meaningful_mtime=False,
47694 1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47693 diff changeset	558 parentfiledata=parentfiledata,
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47693 diff changeset	559 )
47696 ff481c238496 dirstate: properly update `_lastnormaltime` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47695 diff changeset	560 if (
ff481c238496 dirstate: properly update `_lastnormaltime` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47695 diff changeset	561 parentfiledata is not None
ff481c238496 dirstate: properly update `_lastnormaltime` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47695 diff changeset	562 and parentfiledata[2] > self._lastnormaltime
ff481c238496 dirstate: properly update `_lastnormaltime` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47695 diff changeset	563 ):
ff481c238496 dirstate: properly update `_lastnormaltime` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47695 diff changeset	564 # Remember the most recent modification timeslot for status(),
ff481c238496 dirstate: properly update `_lastnormaltime` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47695 diff changeset	565 # to make sure we won't miss future size-preserving file content
ff481c238496 dirstate: properly update `_lastnormaltime` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47695 diff changeset	566 # modifications that happen within the same timeslot.
ff481c238496 dirstate: properly update `_lastnormaltime` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47695 diff changeset	567 self._lastnormaltime = parentfiledata[2]
47694 1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47693 diff changeset	568
47611 e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	569 @requires_parents_change
e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	570 def update_file(
e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	571 self,
e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	572 filename,
e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	573 wc_tracked,
e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	574 p1_tracked,
48156 6f54afb094bd dirstate: align the dirstate's API to the lower level ones Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48153 diff changeset	575 p2_info=False,
47611 e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	576 possibly_dirty=False,
47691 33beeb32f73a dirstate: replace `update_parent_file_data` with simpler `update_parent` call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47690 diff changeset	577 parentfiledata=None,
47611 e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	578 ):
e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	579 """update the information about a file in the dirstate
e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	580
e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	581 This is to be called when the direstates parent changes to keep track
e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	582 of what is the file situation in regards to the working copy and its parent.
e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	583
e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	584 This function must be called within a `dirstate.parentchange` context.
e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	585
47770 03089463c554 dirstate: fix typo in docstring Augie Fackler <augie@google.com> parents: 47757 diff changeset	586 note: the API is at an early stage and we might need to adjust it
47611 e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	587 depending of what information ends up being relevant and useful to
e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	588 other processing.
e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	589 """
47692 e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	590
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	591 # note: I do not think we need to double check name clash here since we
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	592 # are in a update/merge case that should already have taken care of
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	593 # this. The test agrees
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	594
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	595 self._dirty = True
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	596
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	597 need_parent_file_data = (
48156 6f54afb094bd dirstate: align the dirstate's API to the lower level ones Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48153 diff changeset	598 not possibly_dirty and not p2_info and wc_tracked and p1_tracked
47692 e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	599 )
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	600
48158 de0977ec2d25 dirstate: drop an incorrect comment Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48157 diff changeset	601 if need_parent_file_data and parentfiledata is None:
48157 180e8fa345cc dirstate: drop some duplicated code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48156 diff changeset	602 parentfiledata = self._get_filedata(filename)
47692 e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	603
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	604 self._map.reset_state(
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	605 filename,
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	606 wc_tracked,
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	607 p1_tracked,
48156 6f54afb094bd dirstate: align the dirstate's API to the lower level ones Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48153 diff changeset	608 p2_info=p2_info,
48152 98b3eb6c1479 dirstate: align the dirstatemap's API to the data change Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48133 diff changeset	609 has_meaningful_mtime=not possibly_dirty,
47692 e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	610 parentfiledata=parentfiledata,
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47691 diff changeset	611 )
47695 f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47694 diff changeset	612 if (
f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47694 diff changeset	613 parentfiledata is not None
f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47694 diff changeset	614 and parentfiledata[2] > self._lastnormaltime
f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47694 diff changeset	615 ):
f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47694 diff changeset	616 # Remember the most recent modification timeslot for status(),
f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47694 diff changeset	617 # to make sure we won't miss future size-preserving file content
f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47694 diff changeset	618 # modifications that happen within the same timeslot.
f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47694 diff changeset	619 self._lastnormaltime = parentfiledata[2]
47611 e2e72daac90b dirstate: add a `update_file` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47599 diff changeset	620
48001 2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	621 def _check_new_tracked_filename(self, filename):
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	622 scmutil.checkfilename(filename)
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	623 if self._map.hastrackeddir(filename):
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	624 msg = _(b'directory %r already in dirstate')
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	625 msg %= pycompat.bytestr(filename)
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	626 raise error.Abort(msg)
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	627 # shadows
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	628 for d in pathutil.finddirs(filename):
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	629 if self._map.hastrackeddir(d):
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	630 break
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	631 entry = self._map.get(d)
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	632 if entry is not None and not entry.removed:
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	633 msg = _(b'file %r in dirstate clashes with %r')
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	634 msg %= (pycompat.bytestr(d), pycompat.bytestr(filename))
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	635 raise error.Abort(msg)
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48000 diff changeset	636
47690 a685c29ebf54 dirstate: factor out the part retrieve "filedata" out of `normal` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47674 diff changeset	637 def _get_filedata(self, filename):
a685c29ebf54 dirstate: factor out the part retrieve "filedata" out of `normal` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47674 diff changeset	638 """returns"""
a685c29ebf54 dirstate: factor out the part retrieve "filedata" out of `normal` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47674 diff changeset	639 s = os.lstat(self._join(filename))
a685c29ebf54 dirstate: factor out the part retrieve "filedata" out of `normal` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47674 diff changeset	640 mode = s.st_mode
a685c29ebf54 dirstate: factor out the part retrieve "filedata" out of `normal` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47674 diff changeset	641 size = s.st_size
48271 269ff8978086 dirstate: store mtimes with nanosecond precision in memory Simon Sapin <simon.sapin@octobus.net> parents: 48263 diff changeset	642 mtime = timestamp.mtime_of(s)
47690 a685c29ebf54 dirstate: factor out the part retrieve "filedata" out of `normal` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47674 diff changeset	643 return (mode, size, mtime)
a685c29ebf54 dirstate: factor out the part retrieve "filedata" out of `normal` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47674 diff changeset	644
24538 24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	645 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	646 if exists is None:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	647 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	648 if not exists:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	649 # Maybe a path component exists
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	650 if not ignoremissing and b'/' in path:
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	651 d, f = path.rsplit(b'/', 1)
24538 24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	652 d = self._normalize(d, False, ignoremissing, None)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	653 folded = d + b"/" + f
24538 24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	654 else:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	655 # No path components, preserve original case
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	656 folded = path
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	657 else:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	658 # recursively normalize leading directory components
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	659 # against dirstate
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	660 if b'/' in normed:
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	661 d, f = normed.rsplit(b'/', 1)
24538 24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	662 d = self._normalize(d, False, ignoremissing, True)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	663 r = self._root + b"/" + d
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	664 folded = d + b"/" + util.fspath(f, r)
24538 24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	665 else:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	666 folded = util.fspath(normed, self._root)
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	667 storemap[normed] = folded
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	668
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	669 return folded
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	670
24539 3a8eba78803e dirstate: introduce function to normalize just filenames Siddharth Agarwal <sid0@fb.com> parents: 24538 diff changeset	671 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	672 normed = util.normcase(path)
34676 bfddc3d678ae dirstate: remove _filefoldmap property cache Durham Goode <durham@fb.com> parents: 34675 diff changeset	673 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	674 if folded is None:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	675 if isknown:
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	676 folded = path
7068 57377fa7eda2 issue 1286: dirstat regression on case folding systems Petr Kodl <petrkodl@gmail.com> parents: 7034 diff changeset	677 else:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	678 folded = self._discoverpath(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	679 path, normed, ignoremissing, exists, self._map.filefoldmap
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	680 )
24539 3a8eba78803e dirstate: introduce function to normalize just filenames Siddharth Agarwal <sid0@fb.com> parents: 24538 diff changeset	681 return folded
16302 49b54f1ae053 dirstate: normalize case of directory components Matt Mackall <mpm@selenic.com> parents: 16258 diff changeset	682
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	683 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	684 normed = util.normcase(path)
34676 bfddc3d678ae dirstate: remove _filefoldmap property cache Durham Goode <durham@fb.com> parents: 34675 diff changeset	685 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	686 if folded is None:
34678 e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	687 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	688 if folded is None:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	689 if isknown:
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	690 folded = path
7068 57377fa7eda2 issue 1286: dirstat regression on case folding systems Petr Kodl <petrkodl@gmail.com> parents: 7034 diff changeset	691 else:
24540 25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	692 # 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	693 # normalizefile calls don't start matching directories
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	694 folded = self._discoverpath(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	695 path, normed, ignoremissing, exists, self._map.dirfoldmap
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	696 )
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	697 return folded
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	698
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	699 def normalize(self, path, isknown=False, ignoremissing=False):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	700 """
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	701 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	702
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	703 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	704 disk, to avoid extra filesystem access.
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	705
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	706 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	707 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	708 existing path components.
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	709
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	710 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	711
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	712 - 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	713 - version of name stored on disk
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	714 - version provided via command arguments
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	715 """
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	716
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	717 if self._checkcase:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	718 return self._normalize(path, isknown, ignoremissing)
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	719 return path
6677 9865e15febd0 Add a normalize() method to dirstate Paul Moore <p.f.moore@gmail.com> parents: 6675 diff changeset	720
5065 b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	721 def clear(self):
34933 0217f75b6e59 dirstate: move clear onto dirstatemap class Durham Goode <durham@fb.com> parents: 34678 diff changeset	722 self._map.clear()
48271 269ff8978086 dirstate: store mtimes with nanosecond precision in memory Simon Sapin <simon.sapin@octobus.net> parents: 48263 diff changeset	723 self._lastnormaltime = timestamp.zero()
5123 79373ec3f27d merge with crew-stable Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5045 5065 diff changeset	724 self._dirty = True
5065 b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	725
18760 e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	726 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	727 if changedfiles is None:
27176 54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild Christian Delahousse <cdelahousse@fb.com> parents: 27016 diff changeset	728 # Rebuild entire dirstate
43897 7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	729 to_lookup = allfiles
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	730 to_drop = []
27176 54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild Christian Delahousse <cdelahousse@fb.com> parents: 27016 diff changeset	731 lastnormaltime = self._lastnormaltime
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild Christian Delahousse <cdelahousse@fb.com> parents: 27016 diff changeset	732 self.clear()
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild Christian Delahousse <cdelahousse@fb.com> parents: 27016 diff changeset	733 self._lastnormaltime = lastnormaltime
43897 7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	734 elif len(changedfiles) < 10:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	735 # Avoid turning allfiles into a set, which can be expensive if it's
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	736 # large.
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	737 to_lookup = []
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	738 to_drop = []
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	739 for f in changedfiles:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	740 if f in allfiles:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	741 to_lookup.append(f)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	742 else:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	743 to_drop.append(f)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	744 else:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	745 changedfilesset = set(changedfiles)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	746 to_lookup = changedfilesset & set(allfiles)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	747 to_drop = changedfilesset - to_lookup
27176 54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild Christian Delahousse <cdelahousse@fb.com> parents: 27016 diff changeset	748
29783 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	749 if self._origpl is None:
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	750 self._origpl = self._pl
47055 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	751 self._map.setparents(parent, self._nodeconstants.nullid)
43897 7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	752
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	753 for f in to_lookup:
48016 14fa2e583422 dirstate: replace the use of `_normallookup` in `rebuild` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48015 diff changeset	754
14fa2e583422 dirstate: replace the use of `_normallookup` in `rebuild` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48015 diff changeset	755 if self.in_merge:
14fa2e583422 dirstate: replace the use of `_normallookup` in `rebuild` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48015 diff changeset	756 self.set_tracked(f)
14fa2e583422 dirstate: replace the use of `_normallookup` in `rebuild` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48015 diff changeset	757 else:
14fa2e583422 dirstate: replace the use of `_normallookup` in `rebuild` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48015 diff changeset	758 self._map.reset_state(
14fa2e583422 dirstate: replace the use of `_normallookup` in `rebuild` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48015 diff changeset	759 f,
14fa2e583422 dirstate: replace the use of `_normallookup` in `rebuild` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48015 diff changeset	760 wc_tracked=True,
14fa2e583422 dirstate: replace the use of `_normallookup` in `rebuild` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48015 diff changeset	761 p1_tracked=True,
14fa2e583422 dirstate: replace the use of `_normallookup` in `rebuild` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48015 diff changeset	762 )
43897 7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43875 diff changeset	763 for f in to_drop:
48024 1370d695c258 dirstate: use `reset_state` in `rebuild` instead of `dropfile` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48023 diff changeset	764 self._map.reset_state(f)
30028 ba06562a06a2 dirstate: rebuild should update dirstate properly Mateusz Kwapich <mitrandir@fb.com> parents: 29893 diff changeset	765
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	766 self._dirty = True
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	767
32770 b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32702 diff changeset	768 def identity(self):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	769 """Return identity of dirstate itself to detect changing in storage
32770 b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32702 diff changeset	770
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32702 diff changeset	771 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: 32702 diff changeset	772 changes based on the former dirstate out can keep consistency.
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	773 """
34675 c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	774 return self._map.identity
32770 b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32702 diff changeset	775
29687 52ff07e1de91 deprecation: enforce thew 'tr' argument of 'dirstate.write' (API) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 29351 diff changeset	776 def write(self, tr):
4612 17ee7407097f dirstate: simplify dirty handling Matt Mackall <mpm@selenic.com> parents: 4611 diff changeset	777 if not self._dirty:
1794 98b6c1cad58b only write the dirstate when something changed Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1755 diff changeset	778 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	779
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	780 filename = self._filename
29687 52ff07e1de91 deprecation: enforce thew 'tr' argument of 'dirstate.write' (API) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 29351 diff changeset	781 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	782 # '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	783 # 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	784 # 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	785 # 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	786 # 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	787
48070 84e7a86e3a63 dirstate: simplify the ambiguity clearing at write time Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48059 diff changeset	788 # record when mtime start to be ambiguous
26747 beff0b2481b3 dirstate: remove layering violation around writing dirstate out FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26746 diff changeset	789 now = _getfsnow(self._opener)
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	790
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	791 # delay writing in-memory changes out
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	792 tr.addfilegenerator(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	793 b'dirstate',
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	794 (self._filename,),
48070 84e7a86e3a63 dirstate: simplify the ambiguity clearing at write time Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48059 diff changeset	795 lambda f: self._writedirstate(tr, f, now=now),
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	796 location=b'plain',
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	797 )
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	798 return
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	799
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	800 st = self._opener(filename, b"w", atomictemp=True, checkambig=True)
47674 ff97e793ed36 dirstate-v2: Introduce a docket file Simon Sapin <simon.sapin@octobus.net> parents: 47673 diff changeset	801 self._writedirstate(tr, st)
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	802
29783 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	803 def addparentchangecallback(self, category, callback):
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	804 """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: 29687 diff changeset	805
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	806 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: 29687 diff changeset	807 dirstate, (oldp1, oldp2), (newp1, newp2)
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	808
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	809 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: 29687 diff changeset	810 with a newer callback.
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	811 """
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	812 self._plchangecallbacks[category] = callback
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	813
48070 84e7a86e3a63 dirstate: simplify the ambiguity clearing at write time Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48059 diff changeset	814 def _writedirstate(self, tr, st, now=None):
29783 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	815 # notify callbacks about parents change
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	816 if self._origpl is not None and self._origpl != self._pl:
43106 d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43090 diff changeset	817 for c, callback in sorted(
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43090 diff changeset	818 pycompat.iteritems(self._plchangecallbacks)
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43090 diff changeset	819 ):
29783 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	820 callback(self, self._origpl, self._pl)
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29687 diff changeset	821 self._origpl = None
48070 84e7a86e3a63 dirstate: simplify the ambiguity clearing at write time Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48059 diff changeset	822
84e7a86e3a63 dirstate: simplify the ambiguity clearing at write time Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48059 diff changeset	823 if now is None:
84e7a86e3a63 dirstate: simplify the ambiguity clearing at write time Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48059 diff changeset	824 # use the modification time of the newly created temporary file as the
84e7a86e3a63 dirstate: simplify the ambiguity clearing at write time Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48059 diff changeset	825 # filesystem's notion of 'now'
48271 269ff8978086 dirstate: store mtimes with nanosecond precision in memory Simon Sapin <simon.sapin@octobus.net> parents: 48263 diff changeset	826 now = timestamp.mtime_of(util.fstat(st))
27397 6c6b48aca328 dirstate: move delaywrite logic from write to _write Matt Mackall <mpm@selenic.com> parents: 27176 diff changeset	827
6c6b48aca328 dirstate: move delaywrite logic from write to _write Matt Mackall <mpm@selenic.com> parents: 27176 diff changeset	828 # 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	829 # timestamp of each entries in dirstate, because of 'now > mtime'
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	830 delaywrite = self._ui.configint(b'debug', b'dirstate.delaywrite')
27397 6c6b48aca328 dirstate: move delaywrite logic from write to _write Matt Mackall <mpm@selenic.com> parents: 27176 diff changeset	831 if delaywrite > 0:
27398 c81675776c95 dirstate: only invoke delaywrite if relevant Matt Mackall <mpm@selenic.com> parents: 27397 diff changeset	832 # do we have any files to delay for?
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43281 diff changeset	833 for f, e in pycompat.iteritems(self._map):
47532 ccbabaee5c36 dirstate-entry: add a `need_delay` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47531 diff changeset	834 if e.need_delay(now):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	835 import time # to avoid useless import
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	836
27399 425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds Matt Mackall <mpm@selenic.com> parents: 27398 diff changeset	837 # 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	838 # 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	839 clock = time.time()
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds Matt Mackall <mpm@selenic.com> parents: 27398 diff changeset	840 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	841 end = start + delaywrite
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds Matt Mackall <mpm@selenic.com> parents: 27398 diff changeset	842 time.sleep(end - clock)
48271 269ff8978086 dirstate: store mtimes with nanosecond precision in memory Simon Sapin <simon.sapin@octobus.net> parents: 48263 diff changeset	843 # trust our estimate that the end is near now
269ff8978086 dirstate: store mtimes with nanosecond precision in memory Simon Sapin <simon.sapin@octobus.net> parents: 48263 diff changeset	844 now = timestamp.timestamp((end, 0))
27398 c81675776c95 dirstate: only invoke delaywrite if relevant Matt Mackall <mpm@selenic.com> parents: 27397 diff changeset	845 break
27397 6c6b48aca328 dirstate: move delaywrite logic from write to _write Matt Mackall <mpm@selenic.com> parents: 27176 diff changeset	846
47674 ff97e793ed36 dirstate-v2: Introduce a docket file Simon Sapin <simon.sapin@octobus.net> parents: 47673 diff changeset	847 self._map.write(tr, st, now)
48271 269ff8978086 dirstate: store mtimes with nanosecond precision in memory Simon Sapin <simon.sapin@octobus.net> parents: 48263 diff changeset	848 self._lastnormaltime = timestamp.zero()
34673 e2214632c3a2 dirstate: move write into dirstatemap Durham Goode <durham@fb.com> parents: 34672 diff changeset	849 self._dirty = False
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	850
6032 b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	851 def _dirignore(self, f):
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	852 if self._ignore(f):
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	853 return True
43677 0b7733719d21 utils: move finddirs() to pathutil Martin von Zweigbergk <martinvonz@google.com> parents: 43664 diff changeset	854 for p in pathutil.finddirs(f):
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	855 if self._ignore(p):
6032 b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	856 return True
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	857 return False
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	858
27594 0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	859 def _ignorefiles(self):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	860 files = []
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	861 if os.path.exists(self._join(b'.hgignore')):
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	862 files.append(self._join(b'.hgignore'))
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	863 for name, path in self._ui.configitems(b"ui"):
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	864 if name == b'ignore' or name.startswith(b'ignore.'):
27594 0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	865 # 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	866 # 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	867 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	868 return files
0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	869
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	870 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	871 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	872 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	873 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	874 i = files.popleft()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	875 patterns = matchmod.readpatternfile(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	876 i, self._ui.warn, sourceinfo=True
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	877 )
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	878 for pattern, lineno, line in patterns:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	879 kind, p = matchmod._patsplit(pattern, b'glob')
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	880 if kind == b"subinclude":
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	881 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	882 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	883 continue
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	884 m = matchmod.match(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	885 self._root, b'', [], [pattern], warn=self._ui.warn
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	886 )
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	887 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	888 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	889 visited.add(i)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	890 return (None, -1, b"")
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	891
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	892 def _walkexplicit(self, match, subrepos):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	893 """Get stat data about the files explicitly specified by match.
3529 09d99b7e4da0 simplify dirstate walking Matt Mackall <mpm@selenic.com> parents: 3223 diff changeset	894
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	895 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	896 - 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	897 listings mapping subrepos and .hg to None.
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	898 - 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	899 - dirsnotfound is a list of files that the dirstate thinks are
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	900 directories and that were not found."""
6578 f242d3684f83 walk: begin refactoring badmatch handling Matt Mackall <mpm@selenic.com> parents: 6577 diff changeset	901
8681 26f133267cd7 walk: use match.bad callback for filetype messages Matt Mackall <mpm@selenic.com> parents: 8680 diff changeset	902 def badtype(mode):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	903 kind = _(b'unknown')
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	904 if stat.S_ISCHR(mode):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	905 kind = _(b'character device')
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	906 elif stat.S_ISBLK(mode):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	907 kind = _(b'block device')
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	908 elif stat.S_ISFIFO(mode):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	909 kind = _(b'fifo')
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	910 elif stat.S_ISSOCK(mode):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	911 kind = _(b'socket')
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	912 elif stat.S_ISDIR(mode):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	913 kind = _(b'directory')
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	914 return _(b'unsupported file type (type is %s)') % kind
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	915
8676 acd69fc201a5 walk: we always have a badfn Matt Mackall <mpm@selenic.com> parents: 8675 diff changeset	916 badfn = match.bad
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	917 dmap = self._map
5000 46facb73ba8b dirstate: localize a bunch of methods for findfiles Matt Mackall <mpm@selenic.com> parents: 4965 diff changeset	918 lstat = os.lstat
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	919 getkind = stat.S_IFMT
6828 55d65a33da52 dirstate.walk: minor cleanups Matt Mackall <mpm@selenic.com> parents: 6827 diff changeset	920 dirkind = stat.S_IFDIR
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	921 regkind = stat.S_IFREG
2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	922 lnkkind = stat.S_IFLNK
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	923 join = self._join
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	924 dirsfound = []
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	925 foundadd = dirsfound.append
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	926 dirsnotfound = []
19175 63f7bd2e1a46 dirstate._walkexplicit: inline dirsnotfound.append Siddharth Agarwal <sid0@fb.com> parents: 19174 diff changeset	927 notfoundadd = dirsnotfound.append
6820 639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	928
24448 55c449345b10 match: add isexact() method to hide internals Martin von Zweigbergk <martinvonz@google.com> parents: 24212 diff changeset	929 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	930 normalize = self._normalize
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440) Matt Mackall <mpm@selenic.com> parents: 12401 diff changeset	931 else:
18032 a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	932 normalize = None
12907 e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440) Matt Mackall <mpm@selenic.com> parents: 12401 diff changeset	933
12211 798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	934 files = sorted(match.files())
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	935 subrepos.sort()
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	936 i, j = 0, 0
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	937 while i < len(files) and j < len(subrepos):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	938 subpath = subrepos[j] + b"/"
13233 0b30e6148ec5 subrepo: do not report known files inside repositories as unknown Oleg Stepanov <oleg.stepanov@jetbrains.com> parents: 12907 diff changeset	939 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	940 i += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	941 continue
13339 22167be007ed subrepo: fix pruning of subrepo filenames in dirstate (issue2619) trbs <trbs@trbs.net> parents: 13233 diff changeset	942 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	943 del files[i]
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	944 j += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	945
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	946 if not files or b'' in files:
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	947 files = [b'']
42362 7ada598941d2 dirstate: move special handling of files==['.'] together Martin von Zweigbergk <martinvonz@google.com> parents: 42331 diff changeset	948 # constructing the foldmap is expensive, so don't do it for the
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42362 diff changeset	949 # common case where files is ['']
42362 7ada598941d2 dirstate: move special handling of files==['.'] together Martin von Zweigbergk <martinvonz@google.com> parents: 42331 diff changeset	950 normalize = None
10176 24ce8f0c0a39 dirstate: don't check state of subrepo directories Augie Fackler <durin42@gmail.com> parents: 10145 diff changeset	951 results = dict.fromkeys(subrepos)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	952 results[b'.hg'] = None
5000 46facb73ba8b dirstate: localize a bunch of methods for findfiles Matt Mackall <mpm@selenic.com> parents: 4965 diff changeset	953
12211 798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	954 for ff in files:
42362 7ada598941d2 dirstate: move special handling of files==['.'] together Martin von Zweigbergk <martinvonz@google.com> parents: 42331 diff changeset	955 if normalize:
24522 18085e46caa9 dirstate._walkexplicit: drop normpath calls Siddharth Agarwal <sid0@fb.com> parents: 24521 diff changeset	956 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	957 else:
24522 18085e46caa9 dirstate._walkexplicit: drop normpath calls Siddharth Agarwal <sid0@fb.com> parents: 24521 diff changeset	958 nf = ff
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	959 if nf in results:
6820 639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	960 continue
639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	961
639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	962 try:
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	963 st = lstat(join(nf))
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	964 kind = getkind(st.st_mode)
2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	965 if kind == dirkind:
8588 2624f485b9bc dirstate: set more states in step 1 of walk Simon Heimberg <simohe@besonet.ch> parents: 8521 diff changeset	966 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	967 # 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	968 results[nf] = None
24537 2bb13f2b778c dirstate: don't require exact case when adding dirs on icasefs (issue4578) Matt Harbison <matt_harbison@yahoo.com> parents: 24198 diff changeset	969 foundadd((nf, ff))
12401 4cdaf1adafc8 backout most of 4f8067c94729 Matt Mackall <mpm@selenic.com> parents: 12387 diff changeset	970 elif kind == regkind or kind == lnkkind:
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	971 results[nf] = st
6828 55d65a33da52 dirstate.walk: minor cleanups Matt Mackall <mpm@selenic.com> parents: 6827 diff changeset	972 else:
8681 26f133267cd7 walk: use match.bad callback for filetype messages Matt Mackall <mpm@selenic.com> parents: 8680 diff changeset	973 badfn(ff, badtype(kind))
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	974 if nf in dmap:
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	975 results[nf] = None
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	976 except OSError as inst: # nf not found on disk - it is dirstate only
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	977 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	978 results[nf] = None
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	979 else: # does it match a missing directory?
35107 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35106 diff changeset	980 if self._map.hasdir(nf):
23375 a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	981 notfoundadd(nf)
8677 34df078b8b1b walk: simplify logic for badfn clause Matt Mackall <mpm@selenic.com> parents: 8676 diff changeset	982 else:
34040 d5b2beca16c0 python3: wrap all uses of <exception>.strerror with strtolocal Augie Fackler <raf@durin42.com> parents: 33999 diff changeset	983 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	984
36238 deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35935 diff changeset	985 # match.files() may contain explicitly-specified paths that shouldn't
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35935 diff changeset	986 # be taken; drop them from the list of files found. dirsfound/notfound
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35935 diff changeset	987 # aren't filtered here because they will be tested later.
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35935 diff changeset	988 if match.anypats():
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35935 diff changeset	989 for f in list(results):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	990 if f == b'.hg' or f in subrepos:
36238 deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35935 diff changeset	991 # keep sentinel to disable further out-of-repo walks
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35935 diff changeset	992 continue
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35935 diff changeset	993 if not match(f):
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35935 diff changeset	994 del results[f]
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35935 diff changeset	995
25877 85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	996 # 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	997 # 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	998 # 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	999 # 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	1000 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	1001 normed = {}
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	1002
43106 d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43090 diff changeset	1003 for f, st in pycompat.iteritems(results):
25877 85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	1004 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	1005 continue
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	1006
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	1007 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	1008 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	1009
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	1010 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	1011 paths = set()
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	1012 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	1013
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	1014 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	1015
43106 d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43090 diff changeset	1016 for norm, paths in pycompat.iteritems(normed):
25877 85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	1017 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	1018 for path in paths:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1019 folded = self._discoverpath(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1020 path, norm, True, None, self._map.dirfoldmap
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1021 )
25877 85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	1022 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	1023 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	1024
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	1025 return results, dirsfound, dirsnotfound
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1026
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	1027 def walk(self, match, subrepos, unknown, ignored, full=True):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	1028 """
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1029 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	1030 matched by match.
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1031
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	1032 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	1033
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1034 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	1035 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	1036
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	1037 """
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	1038 # 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	1039 # 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	1040 # 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	1041
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1042 if ignored:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1043 ignore = util.never
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1044 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	1045 elif unknown:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	1046 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	1047 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	1048 else:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	1049 # 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	1050 ignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1051 dirignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1052
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1053 matchfn = match.matchfn
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1054 matchalways = match.always()
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1055 matchtdir = match.traversedir
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1056 dmap = self._map
32248 d74b0cff94a9 osutil: proxy through util (and platform) modules (API) Yuya Nishihara <yuya@tcha.org> parents: 32226 diff changeset	1057 listdir = util.listdir
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1058 lstat = os.lstat
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1059 dirkind = stat.S_IFDIR
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1060 regkind = stat.S_IFREG
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1061 lnkkind = stat.S_IFLNK
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1062 join = self._join
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1063
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1064 exact = skipstep3 = False
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1065 if match.isexact(): # match.exact
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1066 exact = True
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1067 dirignore = util.always # skip step 2
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1068 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	1069 skipstep3 = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1070
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1071 if not exact and self._checkcase:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1072 normalize = self._normalize
24541 e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize Siddharth Agarwal <sid0@fb.com> parents: 24540 diff changeset	1073 normalizefile = self._normalizefile
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1074 skipstep3 = False
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1075 else:
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	1076 normalize = self._normalize
24541 e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize Siddharth Agarwal <sid0@fb.com> parents: 24540 diff changeset	1077 normalizefile = None
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1078
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1079 # step 1: find all explicit files
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1080 results, work, dirsnotfound = self._walkexplicit(match, subrepos)
43752 95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls Martin von Zweigbergk <martinvonz@google.com> parents: 43736 diff changeset	1081 if matchtdir:
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls Martin von Zweigbergk <martinvonz@google.com> parents: 43736 diff changeset	1082 for d in work:
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls Martin von Zweigbergk <martinvonz@google.com> parents: 43736 diff changeset	1083 matchtdir(d[0])
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls Martin von Zweigbergk <martinvonz@google.com> parents: 43736 diff changeset	1084 for d in dirsnotfound:
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls Martin von Zweigbergk <martinvonz@google.com> parents: 43736 diff changeset	1085 matchtdir(d)
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	1086
19172 c6cea2e2031b dirstate.walk: pull skipstep3 out of the explicit walk code Siddharth Agarwal <sid0@fb.com> parents: 19171 diff changeset	1087 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	1088 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	1089
6826 eca20fee0728 dirstate.walk: pull directory scanning into top-level loop Matt Mackall <mpm@selenic.com> parents: 6825 diff changeset	1090 # 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	1091 def traverse(work, alreadynormed):
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1092 wadd = work.append
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1093 while work:
43239 6fcdcea2b03a dirstate: add some traces on listdir calls Augie Fackler <augie@google.com> parents: 43117 diff changeset	1094 tracing.counter('dirstate.walk work', len(work))
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	1095 nd = work.pop()
38994 a3cabe9415e1 dirstate: use visitchildrenset in traverse Kyle Lippincott <spectral@google.com> parents: 36998 diff changeset	1096 visitentries = match.visitchildrenset(nd)
a3cabe9415e1 dirstate: use visitchildrenset in traverse Kyle Lippincott <spectral@google.com> parents: 36998 diff changeset	1097 if not visitentries:
32226 8f1a2b848b52 dirstate: optimize walk() by using match.visitdir() Martin von Zweigbergk <martinvonz@google.com> parents: 31553 diff changeset	1098 continue
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1099 if visitentries == b'this' or visitentries == b'all':
38994 a3cabe9415e1 dirstate: use visitchildrenset in traverse Kyle Lippincott <spectral@google.com> parents: 36998 diff changeset	1100 visitentries = None
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1101 skip = None
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1102 if nd != b'':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1103 skip = b'.hg'
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1104 try:
43239 6fcdcea2b03a dirstate: add some traces on listdir calls Augie Fackler <augie@google.com> parents: 43117 diff changeset	1105 with tracing.log('dirstate.walk.traverse listdir %s', nd):
6fcdcea2b03a dirstate: add some traces on listdir calls Augie Fackler <augie@google.com> parents: 43117 diff changeset	1106 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	1107 except OSError as inst:
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1108 if inst.errno in (errno.EACCES, errno.ENOENT):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1109 match.bad(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1110 self.pathto(nd), encoding.strtolocal(inst.strerror)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1111 )
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1112 continue
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1113 raise
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1114 for f, kind, st in entries:
39288 27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38997 diff changeset	1115 # Some matchers may return files in the visitentries set,
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38997 diff changeset	1116 # instead of 'this', if the matcher explicitly mentions them
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38997 diff changeset	1117 # and is not an exactmatcher. This is acceptable; we do not
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38997 diff changeset	1118 # make any hard assumptions about file-or-directory below
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38997 diff changeset	1119 # based on the presence of `f` in visitentries. If
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38997 diff changeset	1120 # visitchildrenset returned a set, we can always skip the
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38997 diff changeset	1121 # entries not in the set it provided regardless of whether
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38997 diff changeset	1122 # they're actually a file or a directory.
38994 a3cabe9415e1 dirstate: use visitchildrenset in traverse Kyle Lippincott <spectral@google.com> parents: 36998 diff changeset	1123 if visitentries and f not in visitentries:
a3cabe9415e1 dirstate: use visitchildrenset in traverse Kyle Lippincott <spectral@google.com> parents: 36998 diff changeset	1124 continue
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1125 if normalizefile:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1126 # 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	1127 # 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	1128 # dmap -- therefore normalizefile is enough
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1129 nf = normalizefile(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1130 nd and (nd + b"/" + f) or f, True, True
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1131 )
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1132 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1133 nf = nd and (nd + b"/" + f) or f
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1134 if nf not in results:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1135 if kind == dirkind:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1136 if not ignore(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1137 if matchtdir:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1138 matchtdir(nf)
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	1139 wadd(nf)
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1140 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	1141 results[nf] = None
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1142 elif kind == regkind or kind == lnkkind:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1143 if nf in dmap:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1144 if matchalways or matchfn(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1145 results[nf] = st
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1146 elif (matchalways or matchfn(nf)) and not ignore(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1147 nf
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1148 ):
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	1149 # 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	1150 if not alreadynormed:
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	1151 nf = normalize(nf, False, True)
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1152 results[nf] = st
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1153 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	1154 results[nf] = None
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1155
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	1156 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	1157 # 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	1158 # expensive directory normalization
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	1159 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	1160 traverse([d], alreadynormed)
536 c15b4bc0a11c Refactor diffrevs/diffdir into changes mpm@selenic.com parents: 529 diff changeset	1161
18812 1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3 Siddharth Agarwal <sid0@fb.com> parents: 18792 diff changeset	1162 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	1163 del results[s]
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1164 del results[b'.hg']
18812 1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3 Siddharth Agarwal <sid0@fb.com> parents: 18792 diff changeset	1165
21115 1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	1166 # 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	1167 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	1168 # 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	1169 # 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	1170 # 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	1171 if not results and matchalways:
31431 2e38a88bbc6c dirstate: use list comprehension to get a list of keys Pulkit Goyal <7895pulkit@gmail.com> parents: 31287 diff changeset	1172 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	1173 else:
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3 Siddharth Agarwal <sid0@fb.com> parents: 18814 diff changeset	1174 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	1175 visit.sort()
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3 Siddharth Agarwal <sid0@fb.com> parents: 18814 diff changeset	1176
18625 2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	1177 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	1178 # 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	1179 # 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	1180 # 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	1181 # The rest must thus be ignored or under a symlink.
33647 377e8ddaebef pathauditor: disable cache of audited paths by default (issue5628) Yuya Nishihara <yuya@tcha.org> parents: 33440 diff changeset	1182 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	1183
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	1184 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	1185 # 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	1186 # 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	1187 # 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	1188 # on disk.
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1189 if (
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1190 normalizefile
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1191 and normalizefile(nf, True, True) in results
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1192 ):
24621 1784ca148392 dirstate.walk: don't report same file stat multiple times Martin von Zweigbergk <martinvonz@google.com> parents: 24537 diff changeset	1193 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	1194 # 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	1195 # 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	1196 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	1197 try:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	1198 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	1199 # 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	1200 except OSError:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	1201 # file doesn't exist
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	1202 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	1203 else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	1204 # 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	1205 # 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	1206 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	1207 else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	1208 # 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	1209 # so stat and check everything we missed.
31514 4d1dd9cf0dca dirstate: use future-proof next(iter) instead of iter.next Augie Fackler <augie@google.com> parents: 31431 diff changeset	1210 iv = iter(visit)
26984 af2663680e95 dirstate: back out 502b56a9e897 Bryan O'Sullivan <bos@serpentine.com> parents: 26887 diff changeset	1211 for st in util.statfiles([join(i) for i in visit]):
31514 4d1dd9cf0dca dirstate: use future-proof next(iter) instead of iter.next Augie Fackler <augie@google.com> parents: 31431 diff changeset	1212 results[next(iv)] = st
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	1213 return results
669 8aa2a282eda4 .hgignore speedups patch incorporating Matt's feedback. mwilli2@localhost.localdomain parents: 667 diff changeset	1214
44540 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1215 def _rust_status(self, matcher, list_clean, list_ignored, list_unknown):
44078 f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1216 # Force Rayon (Rust parallelism library) to respect the number of
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1217 # workers. This is a temporary workaround until Rust code knows
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1218 # how to read the config file.
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1219 numcpus = self._ui.configint(b"worker", b"numcpus")
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1220 if numcpus is not None:
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1221 encoding.environ.setdefault(b'RAYON_NUM_THREADS', b'%d' % numcpus)
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1222
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1223 workers_enabled = self._ui.configbool(b"worker", b"enabled", True)
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1224 if not workers_enabled:
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1225 encoding.environ[b"RAYON_NUM_THREADS"] = b"1"
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1226
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1227 (
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1228 lookup,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1229 modified,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1230 added,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1231 removed,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1232 deleted,
44540 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1233 clean,
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1234 ignored,
44078 f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1235 unknown,
44540 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1236 warnings,
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1237 bad,
44899 4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path Rapha?l Gom?s <rgomes@octobus.net> parents: 44895 diff changeset	1238 traversed,
47356 04d1f17f49e7 dirstate-v2: Write .hg/dirstate back to disk on directory cache changes Simon Sapin <simon.sapin@octobus.net> parents: 47328 diff changeset	1239 dirty,
44078 f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1240 ) = rustmod.status(
48133 5fc2dfb073d6 dirstatemap: rename `_rustmap` to `_map` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48119 diff changeset	1241 self._map._map,
44078 f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1242 matcher,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1243 self._rootdir,
44540 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1244 self._ignorefiles(),
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1245 self._checkexec,
44078 f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1246 self._lastnormaltime,
44540 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1247 bool(list_clean),
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1248 bool(list_ignored),
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1249 bool(list_unknown),
44899 4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path Rapha?l Gom?s <rgomes@octobus.net> parents: 44895 diff changeset	1250 bool(matcher.traversedir),
44078 f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1251 )
44899 4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path Rapha?l Gom?s <rgomes@octobus.net> parents: 44895 diff changeset	1252
47356 04d1f17f49e7 dirstate-v2: Write .hg/dirstate back to disk on directory cache changes Simon Sapin <simon.sapin@octobus.net> parents: 47328 diff changeset	1253 self._dirty \|= dirty
04d1f17f49e7 dirstate-v2: Write .hg/dirstate back to disk on directory cache changes Simon Sapin <simon.sapin@octobus.net> parents: 47328 diff changeset	1254
44899 4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path Rapha?l Gom?s <rgomes@octobus.net> parents: 44895 diff changeset	1255 if matcher.traversedir:
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path Rapha?l Gom?s <rgomes@octobus.net> parents: 44895 diff changeset	1256 for dir in traversed:
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path Rapha?l Gom?s <rgomes@octobus.net> parents: 44895 diff changeset	1257 matcher.traversedir(dir)
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path Rapha?l Gom?s <rgomes@octobus.net> parents: 44895 diff changeset	1258
44540 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1259 if self._ui.warn:
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1260 for item in warnings:
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1261 if isinstance(item, tuple):
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1262 file_path, syntax = item
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1263 msg = _(b"%s: ignoring invalid syntax '%s'\n") % (
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1264 file_path,
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1265 syntax,
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1266 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1267 self._ui.warn(msg)
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1268 else:
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1269 msg = _(b"skipping unreadable pattern file '%s': %s\n")
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1270 self._ui.warn(
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1271 msg
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1272 % (
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1273 pathutil.canonpath(
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1274 self._rootdir, self._rootdir, item
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1275 ),
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1276 b"No such file or directory",
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1277 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1278 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1279
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1280 for (fn, message) in bad:
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1281 matcher.bad(fn, encoding.strtolocal(message))
44078 f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1282
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1283 status = scmutil.status(
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1284 modified=modified,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1285 added=added,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1286 removed=removed,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1287 deleted=deleted,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1288 unknown=unknown,
44540 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1289 ignored=ignored,
44078 f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1290 clean=clean,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1291 )
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1292 return (lookup, status)
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43923 diff changeset	1293
10176 24ce8f0c0a39 dirstate: don't check state of subrepo directories Augie Fackler <durin42@gmail.com> parents: 10145 diff changeset	1294 def status(self, match, subrepos, ignored, clean, unknown):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	1295 """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	1296 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	1297 scmutil.status and:
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1298
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1299 unsure:
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1300 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	1301 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	1302 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	1303 status.modified:
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1304 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	1305 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	1306 status.clean:
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1307 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	1308 dirstate was written
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	1309 """
6753 ed5ffb2c12f3 repo.status: eliminate list_ Matt Mackall <mpm@selenic.com> parents: 6750 diff changeset	1310 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	1311 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	1312 removed, deleted, clean = [], [], []
723 9e0f3ba4a9c2 Work on walk code. Bryan O'Sullivan <bos@serpentine.com> parents: 705 diff changeset	1313
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1314 dmap = self._map
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1315 dmap.preload()
43274 733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43239 diff changeset	1316
733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43239 diff changeset	1317 use_rust = True
43923 40fd1ef4e4c1 rust-matchers: add support for `exactmatcher` in `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43897 diff changeset	1318
44540 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1319 allowed_matchers = (
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1320 matchmod.alwaysmatcher,
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1321 matchmod.exactmatcher,
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1322 matchmod.includematcher,
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1323 )
43923 40fd1ef4e4c1 rust-matchers: add support for `exactmatcher` in `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43897 diff changeset	1324
43274 733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43239 diff changeset	1325 if rustmod is None:
733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43239 diff changeset	1326 use_rust = False
44540 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1327 elif self._checkcase:
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1328 # Case-insensitive filesystems are not handled yet
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1329 use_rust = False
43274 733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43239 diff changeset	1330 elif subrepos:
733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43239 diff changeset	1331 use_rust = False
44540 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1332 elif sparse.enabled:
43274 733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43239 diff changeset	1333 use_rust = False
43923 40fd1ef4e4c1 rust-matchers: add support for `exactmatcher` in `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43897 diff changeset	1334 elif not isinstance(match, allowed_matchers):
44895 63edfea7dfde status: update comment to reflect the more recent situation Rapha?l Gom?s <rgomes@octobus.net> parents: 44878 diff changeset	1335 # Some matchers have yet to be implemented
43274 733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43239 diff changeset	1336 use_rust = False
733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43239 diff changeset	1337
733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43239 diff changeset	1338 if use_rust:
44540 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1339 try:
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1340 return self._rust_status(
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1341 match, listclean, listignored, listunknown
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1342 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1343 except rustmod.FallbackError:
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1344 pass
43274 733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43239 diff changeset	1345
43664 dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API) Martin von Zweigbergk <martinvonz@google.com> parents: 43656 diff changeset	1346 def noop(f):
dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API) Martin von Zweigbergk <martinvonz@google.com> parents: 43656 diff changeset	1347 pass
dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API) Martin von Zweigbergk <martinvonz@google.com> parents: 43656 diff changeset	1348
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1349 dcontains = dmap.__contains__
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1350 dget = dmap.__getitem__
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1351 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	1352 madd = modified.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1353 aadd = added.append
43664 dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API) Martin von Zweigbergk <martinvonz@google.com> parents: 43656 diff changeset	1354 uadd = unknown.append if listunknown else noop
dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API) Martin von Zweigbergk <martinvonz@google.com> parents: 43656 diff changeset	1355 iadd = ignored.append if listignored else noop
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1356 radd = removed.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1357 dadd = deleted.append
43664 dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API) Martin von Zweigbergk <martinvonz@google.com> parents: 43656 diff changeset	1358 cadd = clean.append if listclean else noop
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1359 mexact = match.exact
1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1360 dirignore = self._dirignore
1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1361 checkexec = self._checkexec
34343 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34342 diff changeset	1362 copymap = self._map.copymap
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1363 lastnormaltime = self._lastnormaltime
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1364
19191 ab9de1e8fc36 dirstate.status: avoid full walks when possible Siddharth Agarwal <sid0@fb.com> parents: 19190 diff changeset	1365 # 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	1366 # - we're listing all clean files, or
ab9de1e8fc36 dirstate.status: avoid full walks when possible Siddharth Agarwal <sid0@fb.com> parents: 19190 diff changeset	1367 # - 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	1368 # 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	1369 full = listclean or match.traversedir is not None
43106 d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43090 diff changeset	1370 for fn, st in pycompat.iteritems(
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43090 diff changeset	1371 self.walk(match, subrepos, listunknown, listignored, full=full)
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43090 diff changeset	1372 ):
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1373 if not dcontains(fn):
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1374 if (listignored or mexact(fn)) and dirignore(fn):
6753 ed5ffb2c12f3 repo.status: eliminate list_ Matt Mackall <mpm@selenic.com> parents: 6750 diff changeset	1375 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	1376 iadd(fn)
19910 601944f41257 dirstate.status: return explicit unknown files even when not asked Siddharth Agarwal <sid0@fb.com> parents: 19651 diff changeset	1377 else:
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1378 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	1379 continue
6591 eda3fd322a7f dirstate: minor status cleanups Matt Mackall <mpm@selenic.com> parents: 6590 diff changeset	1380
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1381 t = dget(fn)
47536 8e4b9fe31334 dirstate-entry: add a `mode` property Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47535 diff changeset	1382 mode = t.mode
47537 0e5800c88eb4 dirstate-entry: add a `size` property Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47536 diff changeset	1383 size = t.size
6591 eda3fd322a7f dirstate: minor status cleanups Matt Mackall <mpm@selenic.com> parents: 6590 diff changeset	1384
47531 f5b8f0b9c129 dirstate-entry: add a `tracked` property Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47530 diff changeset	1385 if not st and t.tracked:
6818 6e93fbd847ef dirstate.walk: eliminate src from yield Matt Mackall <mpm@selenic.com> parents: 6811 diff changeset	1386 dadd(fn)
48160 e2753a7acfa7 dirstate-item: use the `p2_info` property to replace more verbose call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48159 diff changeset	1387 elif t.p2_info:
47533 174d0bcce2eb dirstate: reorder "state" checking conditional Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47532 diff changeset	1388 madd(fn)
174d0bcce2eb dirstate: reorder "state" checking conditional Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47532 diff changeset	1389 elif t.added:
174d0bcce2eb dirstate: reorder "state" checking conditional Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47532 diff changeset	1390 aadd(fn)
174d0bcce2eb dirstate: reorder "state" checking conditional Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47532 diff changeset	1391 elif t.removed:
174d0bcce2eb dirstate: reorder "state" checking conditional Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47532 diff changeset	1392 radd(fn)
47534 e53a42dce923 dirstate: drop last explicite `state` usage in status Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47533 diff changeset	1393 elif t.tracked:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1394 if (
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1395 size >= 0
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1396 and (
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1397 (size != st.st_size and size != st.st_size & _rangemask)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1398 or ((mode ^ st.st_mode) & 0o100 and checkexec)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1399 )
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1400 or fn in copymap
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1401 ):
46410 ca69e29a2a30 formatting: fix redundant parentheses Rapha?l Gom?s <rgomes@octobus.net> parents: 46385 diff changeset	1402 if stat.S_ISLNK(st.st_mode) and size != st.st_size:
46385 0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt Corey Schuhen <cschuhen@topcon.com> parents: 45957 diff changeset	1403 # issue6456: Size returned may be longer due to
0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt Corey Schuhen <cschuhen@topcon.com> parents: 45957 diff changeset	1404 # encryption on EXT-4 fscrypt, undecided.
0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt Corey Schuhen <cschuhen@topcon.com> parents: 45957 diff changeset	1405 ladd(fn)
0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt Corey Schuhen <cschuhen@topcon.com> parents: 45957 diff changeset	1406 else:
0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt Corey Schuhen <cschuhen@topcon.com> parents: 45957 diff changeset	1407 madd(fn)
48271 269ff8978086 dirstate: store mtimes with nanosecond precision in memory Simon Sapin <simon.sapin@octobus.net> parents: 48263 diff changeset	1408 elif not t.mtime_likely_equal_to(timestamp.mtime_of(st)):
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1409 ladd(fn)
48271 269ff8978086 dirstate: store mtimes with nanosecond precision in memory Simon Sapin <simon.sapin@octobus.net> parents: 48263 diff changeset	1410 elif timestamp.mtime_of(st) == lastnormaltime:
24181 5245caa0dcde dirstate: clarify comment about leaving normal files undef if changed 'now' Mads Kiilerich <madski@unity3d.com> parents: 23866 diff changeset	1411 # 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	1412 # 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	1413 # This can happen if we quickly do multiple commits.
13763 7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	1414 # 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	1415 ladd(fn)
6753 ed5ffb2c12f3 repo.status: eliminate list_ Matt Mackall <mpm@selenic.com> parents: 6750 diff changeset	1416 elif listclean:
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1417 cadd(fn)
44540 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1418 status = scmutil.status(
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1419 modified, added, removed, deleted, unknown, ignored, clean
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1420 )
44540 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44391 diff changeset	1421 return (lookup, status)
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1422
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1423 def matches(self, match):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	1424 """
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1425 return files in the dirstate (in whatever state) filtered by match
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45269 diff changeset	1426 """
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1427 dmap = self._map
44391 bed8d08cfcb2 rust-dirstatemap: remove additional lookup in dirstate.matches Rapha?l Gom?s <rgomes@octobus.net> parents: 44181 diff changeset	1428 if rustmod is not None:
48133 5fc2dfb073d6 dirstatemap: rename `_rustmap` to `_map` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48119 diff changeset	1429 dmap = self._map._map
44391 bed8d08cfcb2 rust-dirstatemap: remove additional lookup in dirstate.matches Rapha?l Gom?s <rgomes@octobus.net> parents: 44181 diff changeset	1430
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1431 if match.always():
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1432 return dmap.keys()
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1433 files = match.files()
24448 55c449345b10 match: add isexact() method to hide internals Martin von Zweigbergk <martinvonz@google.com> parents: 24212 diff changeset	1434 if match.isexact():
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1435 # 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	1436 # much smaller than dmap
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1437 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	1438 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	1439 # 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	1440 # that
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1441 return list(files)
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1442 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	1443
26746 3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26635 diff changeset	1444 def _actualfilename(self, tr):
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26635 diff changeset	1445 if tr:
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1446 return self._pendingfilename
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1447 else:
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1448 return self._filename
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1449
33440 ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1450 def savebackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1451 '''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	1452 filename = self._actualfilename(tr)
33440 ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1453 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	1454
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1455 # 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	1456 # 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	1457 # output file will be used to create backup of dirstate at this point.
31218 fc57a8b95f1b dirstate: avoid unnecessary load+dump during backup Jun Wu <quark@fb.com> parents: 31217 diff changeset	1458 if self._dirty or not self._opener.exists(filename):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1459 self._writedirstate(
47674 ff97e793ed36 dirstate-v2: Introduce a docket file Simon Sapin <simon.sapin@octobus.net> parents: 47673 diff changeset	1460 tr,
ff97e793ed36 dirstate-v2: Introduce a docket file Simon Sapin <simon.sapin@octobus.net> parents: 47673 diff changeset	1461 self._opener(filename, b"w", atomictemp=True, checkambig=True),
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1462 )
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1463
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1464 if tr:
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1465 # 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	1466 # 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	1467 # changed after this
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1468 tr.addfilegenerator(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1469 b'dirstate',
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1470 (self._filename,),
47674 ff97e793ed36 dirstate-v2: Introduce a docket file Simon Sapin <simon.sapin@octobus.net> parents: 47673 diff changeset	1471 lambda f: self._writedirstate(tr, f),
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1472 location=b'plain',
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1473 )
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1474
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1475 # 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	1476 # 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	1477 # end of this transaction
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1478 tr.registertmp(filename, location=b'plain')
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1479
31553 ddadb6b0b58e dirstate: use tryunlink Ryan McElroy <rmcelroy@fb.com> parents: 31514 diff changeset	1480 self._opener.tryunlink(backupname)
31217 1ef37b16b8e8 dirstate: try to use hardlink to backup dirstate Jun Wu <quark@fb.com> parents: 31216 diff changeset	1481 # hardlink backup is okay because _writedirstate is always called
1ef37b16b8e8 dirstate: try to use hardlink to backup dirstate Jun Wu <quark@fb.com> parents: 31216 diff changeset	1482 # with an "atomictemp=True" file.
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1483 util.copyfile(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1484 self._opener.join(filename),
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1485 self._opener.join(backupname),
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1486 hardlink=True,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42931 diff changeset	1487 )
26632 59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1488
33440 ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1489 def restorebackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1490 '''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	1491 # 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	1492 # 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	1493 self.invalidate()
26746 3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26635 diff changeset	1494 filename = self._actualfilename(tr)
34940 c2b30348930f dirstate: clean up when restoring identical backups Mark Thomas <mbthomas@fb.com> parents: 34935 diff changeset	1495 o = self._opener
c2b30348930f dirstate: clean up when restoring identical backups Mark Thomas <mbthomas@fb.com> parents: 34935 diff changeset	1496 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	1497 o.unlink(backupname)
c2b30348930f dirstate: clean up when restoring identical backups Mark Thomas <mbthomas@fb.com> parents: 34935 diff changeset	1498 else:
c2b30348930f dirstate: clean up when restoring identical backups Mark Thomas <mbthomas@fb.com> parents: 34935 diff changeset	1499 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	1500
33440 ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1501 def clearbackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1502 '''Clear backup file'''
ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1503 self._opener.unlink(backupname)
48101 c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1504
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1505 def verify(self, m1, m2):
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1506 """check the dirstate content again the parent manifest and yield errors"""
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1507 missing_from_p1 = b"%s in state %s, but not in manifest1\n"
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1508 unexpected_in_p1 = b"%s in state %s, but also in manifest1\n"
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1509 missing_from_ps = b"%s in state %s, but not in either manifest\n"
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1510 missing_from_ds = b"%s in manifest1, but listed as state %s\n"
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1511 for f, entry in self.items():
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1512 state = entry.state
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1513 if state in b"nr" and f not in m1:
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1514 yield (missing_from_p1, f, state)
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1515 if state in b"a" and f in m1:
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1516 yield (unexpected_in_p1, f, state)
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1517 if state in b"m" and f not in m1 and f not in m2:
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1518 yield (missing_from_ps, f, state)
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1519 for f in m1:
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1520 state = self.get_entry(f).state
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1521 if state not in b"nrm":
c87844960a35 dirstate: move verification code within the dirstate itself Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48097 diff changeset	1522 yield (missing_from_ds, f, state)

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/dirstate.py @ 48290:91f07430db8c