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

annotate mercurial/dirstate.py @ 47482:cb29484eaade

dirstate: introduce a symbolic constant for the FROM_P2 marker This is going to be clearer and easier to track than -2. Ultimately I would like to get ride of this special value everywhere but in the lower level, however we need to clarify the API first. This changeset is part of such clarification. Differential Revision: https://phab.mercurial-scm.org/D10926

author	Pierre-Yves David <pierre-yves.david@octobus.net>
date	Thu, 01 Jul 2021 19:04:11 +0200
parents	612f5f36fcf6
children	4ac418b4a6af

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: 46794 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
32346 73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	11 import contextlib
27503 0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	12 import errno
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	13 import os
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	14 import stat
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	15
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	16 from .i18n import _
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 (
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	22 encoding,
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	23 error,
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	24 match as matchmod,
0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	25 pathutil,
32372 df448de7cf3b parsers: switch to policy importer Yuya Nishihara <yuya@tcha.org> parents: 32352 diff changeset	26 policy,
30304 ba2c04059317 py3: use pycompat.ossep at certain places Pulkit Goyal <7895pulkit@gmail.com> parents: 30224 diff changeset	27 pycompat,
27503 0f4596622273 dirstate: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27399 diff changeset	28 scmutil,
44530 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	29 sparse,
31050 206532700213 txnutil: factor out the logic to read file in according to HG_PENDING FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 30634 diff changeset	30 txnutil,
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
42927 d459cd8ea42d interfaces: introduce an interface for dirstate implementations Augie Fackler <augie@google.com> parents: 42755 diff changeset	34 from .interfaces import (
d459cd8ea42d interfaces: introduce an interface for dirstate implementations Augie Fackler <augie@google.com> parents: 42755 diff changeset	35 dirstate as intdirstate,
d459cd8ea42d interfaces: introduce an interface for dirstate implementations Augie Fackler <augie@google.com> parents: 42755 diff changeset	36 util as interfaceutil,
d459cd8ea42d interfaces: introduce an interface for dirstate implementations Augie Fackler <augie@google.com> parents: 42755 diff changeset	37 )
d459cd8ea42d interfaces: introduce an interface for dirstate implementations Augie Fackler <augie@google.com> parents: 42755 diff changeset	38
43506 9f70512ae2cf cleanup: remove pointless r-prefixes on single-quoted strings Augie Fackler <augie@google.com> parents: 43505 diff changeset	39 parsers = policy.importmod('parsers')
9f70512ae2cf cleanup: remove pointless r-prefixes on single-quoted strings Augie Fackler <augie@google.com> parents: 43505 diff changeset	40 rustmod = policy.importrust('dirstate')
32372 df448de7cf3b parsers: switch to policy importer Yuya Nishihara <yuya@tcha.org> parents: 32352 diff changeset	41
47277 ed0d54b20c5b dirstate-v2: Add a new experimental `exp-dirstate-v2` repository requirement Simon Sapin <simon.sapin@octobus.net> parents: 47122 diff changeset	42 SUPPORTS_DIRSTATE_V2 = rustmod is not None
ed0d54b20c5b dirstate-v2: Add a new experimental `exp-dirstate-v2` repository requirement Simon Sapin <simon.sapin@octobus.net> parents: 47122 diff changeset	43
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	44 propertycache = util.propertycache
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	45 filecache = scmutil.filecache
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	46 _rangemask = 0x7FFFFFFF
16201 fb7c4c14223f dirstate: filecacheify _branch Idan Kamara <idankk86@gmail.com> parents: 16200 diff changeset	47
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	48 dirstatetuple = parsers.dirstatetuple
21808 7537e57f5dbd dirstate: add dirstatetuple to create dirstate values Siddharth Agarwal <sid0@fb.com> parents: 21116 diff changeset	49
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	50
47482 cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47481 diff changeset	51 # a special value used internally for `size` if the file come from the other parent
cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47481 diff changeset	52 FROM_P2 = -2
cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47481 diff changeset	53
cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47481 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: 42927 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: 42927 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: 42927 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: 42927 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:
36781 ffa3026d4196 cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime Augie Fackler <augie@google.com> parents: 36622 diff changeset	73 return os.fstat(tmpfd)[stat.ST_MTIME]
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	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: 42927 diff changeset	78
42927 d459cd8ea42d interfaces: introduce an interface for dirstate implementations Augie Fackler <augie@google.com> parents: 42755 diff changeset	79 @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	80 class dirstate(object):
46780 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 45942 diff changeset	81 def __init__(
47280 1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	82 self,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	83 opener,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	84 ui,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	85 root,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	86 validate,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	87 sparsematchfn,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	88 nodeconstants,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	89 use_dirstate_v2,
46780 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 45942 diff changeset	90 ):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	91 """Create a new dirstate object.
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	92
aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	93 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	94 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	95 the dirstate.
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	96 """
47280 1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	97 self._use_dirstate_v2 = use_dirstate_v2
46780 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 45942 diff changeset	98 self._nodeconstants = nodeconstants
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	99 self._opener = opener
13032 e41e2b79883d dirstate: warn on invalid parents rather than aborting Matt Mackall <mpm@selenic.com> parents: 12907 diff changeset	100 self._validate = validate
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	101 self._root = root
33373 fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	102 self._sparsematchfn = sparsematchfn
24198 3cc630be5f09 dirstate: make sure rootdir ends with directory separator (issue4557) Yuya Nishihara <yuya@tcha.org> parents: 23866 diff changeset	103 # 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	104 # 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	105 self._rootdir = pathutil.normasprefix(root)
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	106 self._dirty = False
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15670 diff changeset	107 self._lastnormaltime = 0
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	108 self._ui = ui
16200 9d4a2942a732 dirstate: add filecache support Idan Kamara <idankk86@gmail.com> parents: 16143 diff changeset	109 self._filecache = {}
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	110 self._parentwriters = 0
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	111 self._filename = b'dirstate'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	112 self._pendingfilename = b'%s.pending' % self._filename
29772 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	113 self._plchangecallbacks = {}
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	114 self._origpl = None
31206 49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	115 self._updatedfiles = set()
35086 8db4ca768416 dirstate: make map implementation overridable Mark Thomas <mbthomas@fb.com> parents: 35084 diff changeset	116 self._mapcls = dirstatemap
41674 e178b131906a dirstate: call and cache os.getcwd() in constructor Martin von Zweigbergk <martinvonz@google.com> parents: 40424 diff changeset	117 # 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: 40424 diff changeset	118 # 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: 40424 diff changeset	119 # raises an exception).
e178b131906a dirstate: call and cache os.getcwd() in constructor Martin von Zweigbergk <martinvonz@google.com> parents: 40424 diff changeset	120 self._cwd
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	121
44826 35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44825 diff changeset	122 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: 44825 diff changeset	123 """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: 44825 diff changeset	124
35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44825 diff changeset	125 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: 44825 diff changeset	126 """
35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44825 diff changeset	127 self._pl
35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44825 diff changeset	128
32346 73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	129 @contextlib.contextmanager
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	130 def parentchange(self):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	131 """Context manager for handling dirstate parents.
32346 73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	132
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	133 If an exception occurs in the scope of the context manager,
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	134 the incoherent dirstate won't be written when wlock is
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	135 released.
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	136 """
32346 73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	137 self._parentwriters += 1
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	138 yield
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	139 # Typically we want the "undo" step of a context manager in a
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	140 # finally block so it happens even when an exception
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	141 # occurs. In this case, however, we only want to decrement
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	142 # parentwriters if the code in the with statement exits
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	143 # normally, so we don't have a try/finally here on purpose.
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	144 self._parentwriters -= 1
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes Augie Fackler <augie@google.com> parents: 32208 diff changeset	145
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	146 def pendingparentchange(self):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	147 """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	148 that modify the dirstate parent.
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	149 """
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	150 return self._parentwriters > 0
723 9e0f3ba4a9c2 Work on walk code. Bryan O'Sullivan <bos@serpentine.com> parents: 705 diff changeset	151
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	152 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	153 def _map(self):
35078 a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	154 """Return the dirstate contents (see documentation for dirstatemap)."""
46780 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 45942 diff changeset	155 self._map = self._mapcls(
47280 1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	156 self._ui,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	157 self._opener,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	158 self._root,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	159 self._nodeconstants,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	160 self._use_dirstate_v2,
46780 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 45942 diff changeset	161 )
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	162 return self._map
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	163
33373 fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	164 @property
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	165 def _sparsematcher(self):
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	166 """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	167
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	168 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	169 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	170 included in the working directory.
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	171 """
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	172 # 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	173 # 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	174 # 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	175 return self._sparsematchfn()
fb320398a21c dirstate: expose a sparse matcher on dirstate (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 33215 diff changeset	176
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	177 @repocache(b'branch')
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	178 def _branch(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	179 try:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	180 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	181 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	182 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	183 raise
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	184 return b"default"
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	185
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	186 @property
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	187 def _pl(self):
34338 0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class Durham Goode <durham@fb.com> parents: 34337 diff changeset	188 return self._map.parents()
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	189
35084 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	190 def hasdir(self, d):
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	191 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	192
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	193 @rootcache(b'.hgignore')
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	194 def _ignore(self):
27594 0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	195 files = self._ignorefiles()
25216 dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25163 diff changeset	196 if not files:
41676 0531dff73d0b match: delete unused root and cwd arguments from {always,never,exact}() (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41674 diff changeset	197 return matchmod.never()
25216 dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25163 diff changeset	198
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	199 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	200 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	201
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	202 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	203 def _slash(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	204 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	205
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	206 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	207 def _checklink(self):
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	208 return util.checklink(self._root)
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	209
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	210 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	211 def _checkexec(self):
44801 373dd22ae60e dirstate: force _checkexec to return a bool Mitchell Plamann <mplamann@janestreet.com> parents: 44530 diff changeset	212 return bool(util.checkexec(self._root))
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	213
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	214 @propertycache
0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	215 def _checkcase(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	216 return not util.fscasesensitive(self._join(b'.hg'))
8261 0fe1f57ac2bd dirstate: use propertycache Matt Mackall <mpm@selenic.com> parents: 8226 diff changeset	217
4905 fc61495ea9cf dirstate: make wjoin function private Matt Mackall <mpm@selenic.com> parents: 4904 diff changeset	218 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	219 # 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	220 # 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	221 return self._rootdir + f
723 9e0f3ba4a9c2 Work on walk code. Bryan O'Sullivan <bos@serpentine.com> parents: 705 diff changeset	222
15337 cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	223 def flagfunc(self, buildfallback):
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	224 if self._checklink and self._checkexec:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	225
15337 cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	226 def f(x):
18869 e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	227 try:
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	228 st = os.lstat(self._join(x))
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	229 if util.statislink(st):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	230 return b'l'
18869 e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	231 if util.statisexec(st):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	232 return b'x'
18869 e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	233 except OSError:
e8b4b139a545 dirstate: only call lstat once per flags invocation Bryan O'Sullivan <bryano@fb.com> parents: 18815 diff changeset	234 pass
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	235 return b''
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	236
15337 cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	237 return f
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	238
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	239 fallback = buildfallback()
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	240 if self._checklink:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	241
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	242 def f(x):
6972 63d1d3e489f8 performance: normalize self._root, avoid calling os.path.join() in dirstate Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 6971 diff changeset	243 if os.path.islink(self._join(x)):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	244 return b'l'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	245 if b'x' in fallback(x):
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	246 return b'x'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	247 return b''
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	248
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	249 return f
86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	250 if self._checkexec:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	251
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	252 def f(x):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	253 if b'l' in fallback(x):
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	254 return b'l'
14273 38af0f514134 rename util.is_exec to isexec Adrian Buehlmann <adrian@cadifra.com> parents: 14168 diff changeset	255 if util.isexec(self._join(x)):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	256 return b'x'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	257 return b''
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	258
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	259 return f
15337 cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	260 else:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802) Matt Mackall <mpm@selenic.com> parents: 15057 diff changeset	261 return fallback
6743 86e8187b721a simplify flag handling Matt Mackall <mpm@selenic.com> parents: 6685 diff changeset	262
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	263 @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	264 def _cwd(self):
33215 b7f6885cb055 dirstate: centralize _cwd handling into _cwd method FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32772 diff changeset	265 # internal config: ui.forcecwd
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	266 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: 32772 diff changeset	267 if forcecwd:
b7f6885cb055 dirstate: centralize _cwd handling into _cwd method FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32772 diff changeset	268 return forcecwd
39818 24e493ec2229 py3: rename pycompat.getcwd() to encoding.getcwd() (API) Matt Harbison <matt_harbison@yahoo.com> parents: 39452 diff changeset	269 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	270
870 a82eae840447 Teach walk code about absolute paths. Bryan O'Sullivan <bos@serpentine.com> parents: 839 diff changeset	271 def getcwd(self):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	272 """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	273
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path Yuya Nishihara <yuya@tcha.org> parents: 25877 diff changeset	274 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	275 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	276 used to get real file paths. Use vfs functions instead.
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	277 """
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	278 cwd = self._cwd
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	279 if cwd == self._root:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	280 return b''
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	281 # 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	282 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	283 if not util.endswithsep(rootsep):
30614 cfe66dcf45c0 py3: replace os.sep with pycompat.ossep (part 2 of 4) Pulkit Goyal <7895pulkit@gmail.com> parents: 30519 diff changeset	284 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	285 if cwd.startswith(rootsep):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	286 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	287 else:
c93562fb12cc Fix handling of paths when run outside the repo. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4229 diff changeset	288 # 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	289 return cwd
870 a82eae840447 Teach walk code about absolute paths. Bryan O'Sullivan <bos@serpentine.com> parents: 839 diff changeset	290
4525 78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	291 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	292 if cwd is None:
78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	293 cwd = self.getcwd()
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	294 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	295 if self._slash:
19210 865beb849720 dirstate: don't overnormalize for ui.slash Matt Mackall <mpm@selenic.com> parents: 19128 diff changeset	296 return util.pconvert(path)
4527 b422b558015b Add ui.slash hgrc setting Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4525 diff changeset	297 return path
4525 78b6add1f966 Add dirstate.pathto and localrepo.pathto. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4507 diff changeset	298
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	299 def __getitem__(self, key):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	300 """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	301
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	302 States are:
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	303 n normal
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	304 m needs merging
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	305 r marked for removal
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	306 a marked for addition
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	307 ? not tracked
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	308 """
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	309 return self._map.get(key, (b"?",))[0]
220 3113a94c1bff change dircache into dirstate mpm@selenic.com parents: 217 diff changeset	310
3113a94c1bff change dircache into dirstate mpm@selenic.com parents: 217 diff changeset	311 def __contains__(self, key):
4614 a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	312 return key in self._map
a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	313
a8be3c875988 dirstate: hide internal vars Matt Mackall <mpm@selenic.com> parents: 4613 diff changeset	314 def __iter__(self):
33707 36d216dcae6a dirstate: simplify dirstate's __iter__ Alex Gaynor <agaynor@mozilla.com> parents: 33440 diff changeset	315 return iter(sorted(self._map))
220 3113a94c1bff change dircache into dirstate mpm@selenic.com parents: 217 diff changeset	316
32550 b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32372 diff changeset	317 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	318 return pycompat.iteritems(self._map)
18792 10669e24eb6c completion: add a debugpathcomplete command Bryan O'Sullivan <bryano@fb.com> parents: 18760 diff changeset	319
32550 b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32372 diff changeset	320 iteritems = items
b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32372 diff changeset	321
47351 3b9914b28133 dirstate-v2: Add --dirs to debugdirstate command Simon Sapin <simon.sapin@octobus.net> parents: 47350 diff changeset	322 def directories(self):
3b9914b28133 dirstate-v2: Add --dirs to debugdirstate command Simon Sapin <simon.sapin@octobus.net> parents: 47350 diff changeset	323 return self._map.directories()
3b9914b28133 dirstate-v2: Add --dirs to debugdirstate command Simon Sapin <simon.sapin@octobus.net> parents: 47350 diff changeset	324
227 f57519cddd3d move repo.current to dirstate.parents() mpm@selenic.com parents: 225 diff changeset	325 def parents(self):
13032 e41e2b79883d dirstate: warn on invalid parents rather than aborting Matt Mackall <mpm@selenic.com> parents: 12907 diff changeset	326 return [self._validate(p) for p in self._pl]
227 f57519cddd3d move repo.current to dirstate.parents() mpm@selenic.com parents: 225 diff changeset	327
13876 10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	328 def p1(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	329 return self._validate(self._pl[0])
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	330
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	331 def p2(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	332 return self._validate(self._pl[1])
10c7d92ac482 dirstate: add p1/p2 convenience methods Matt Mackall <mpm@selenic.com> parents: 13763 diff changeset	333
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	334 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	335 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	336
47012 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	337 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	338 """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	339
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	340 When moving from two parents to one, 'm' merged entries a
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	341 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	342 returned by the call.
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	343
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	344 See localrepo.setparents()
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	345 """
47012 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	346 if p2 is None:
d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	347 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	348 if self._parentwriters == 0:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	349 raise ValueError(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	350 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	351 b"dirstate.parentchange context manager"
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	352 )
22407 d259322a394b dirstate: add exception when calling setparent without begin/end (API) Durham Goode <durham@fb.com> parents: 22404 diff changeset	353
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	354 self._dirty = True
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	355 oldp2 = self._pl[1]
29772 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	356 if self._origpl is None:
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	357 self._origpl = self._pl
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	358 self._map.setparents(p1, p2)
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	359 copies = {}
47012 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	360 if (
d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	361 oldp2 != self._nodeconstants.nullid
d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	362 and p2 == self._nodeconstants.nullid
d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	363 ):
47094 e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets Simon Sapin <simon.sapin@octobus.net> parents: 47012 diff changeset	364 candidatefiles = self._map.non_normal_or_other_parent_paths()
e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets Simon Sapin <simon.sapin@octobus.net> parents: 47012 diff changeset	365
31278 1c97a91a18dc dirstate: track otherparent files same as nonnormal Durham Goode <durham@fb.com> parents: 31208 diff changeset	366 for f in candidatefiles:
1c97a91a18dc dirstate: track otherparent files same as nonnormal Durham Goode <durham@fb.com> parents: 31208 diff changeset	367 s = self._map.get(f)
1c97a91a18dc dirstate: track otherparent files same as nonnormal Durham Goode <durham@fb.com> parents: 31208 diff changeset	368 if s is None:
1c97a91a18dc dirstate: track otherparent files same as nonnormal Durham Goode <durham@fb.com> parents: 31208 diff changeset	369 continue
1c97a91a18dc dirstate: track otherparent files same as nonnormal Durham Goode <durham@fb.com> parents: 31208 diff changeset	370
22895 dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents Matt Mackall <mpm@selenic.com> parents: 22782 diff changeset	371 # Discard 'm' markers when moving away from a merge state
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	372 if s[0] == b'm':
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	373 source = self._map.copymap.get(f)
33981 5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible Michael Bolin <mbolin@fb.com> parents: 33737 diff changeset	374 if source:
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible Michael Bolin <mbolin@fb.com> parents: 33737 diff changeset	375 copies[f] = source
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	376 self.normallookup(f)
22895 dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents Matt Mackall <mpm@selenic.com> parents: 22782 diff changeset	377 # Also fix up otherparent markers
47482 cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47481 diff changeset	378 elif s[0] == b'n' and s[2] == FROM_P2:
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	379 source = self._map.copymap.get(f)
33981 5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible Michael Bolin <mbolin@fb.com> parents: 33737 diff changeset	380 if source:
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible Michael Bolin <mbolin@fb.com> parents: 33737 diff changeset	381 copies[f] = source
22895 dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents Matt Mackall <mpm@selenic.com> parents: 22782 diff changeset	382 self.add(f)
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16542 diff changeset	383 return copies
227 f57519cddd3d move repo.current to dirstate.parents() mpm@selenic.com parents: 225 diff changeset	384
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	385 def setbranch(self, branch):
40424 7caf632e30c3 filecache: unimplement __set__() and __delete__() (API) Yuya Nishihara <yuya@tcha.org> parents: 39818 diff changeset	386 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	387 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	388 try:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	389 f.write(self._branch + b'\n')
16472 14a4e17f0817 dirstate: write branch file atomically Idan Kamara <idankk86@gmail.com> parents: 16323 diff changeset	390 f.close()
18317 365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	391
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	392 # 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	393 # replacing the underlying file
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	394 ce = self._filecache[b'_branch']
18317 365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	395 if ce:
365fecd984c7 dirstate: refresh _branch cache entry after writing it Idan Kamara <idankk86@gmail.com> parents: 18078 diff changeset	396 ce.refresh()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	397 except: # re-raises
18076 3bc21f6daac4 dirstate: don't rename branch file if writing it failed Idan Kamara <idankk86@gmail.com> parents: 17984 diff changeset	398 f.discard()
3bc21f6daac4 dirstate: don't rename branch file if writing it failed Idan Kamara <idankk86@gmail.com> parents: 17984 diff changeset	399 raise
4179 7e1c8a565a4f Move branch read/write to dirstate where it belongs Matt Mackall <mpm@selenic.com> parents: 4172 diff changeset	400
4613 3a645af7fb76 localrepo and dirstate: rename reload to invalidate Matt Mackall <mpm@selenic.com> parents: 4612 diff changeset	401 def invalidate(self):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	402 """Causes the next access to reread the dirstate.
32682 e696f597d02f dirstate: add docstring for invalidate Siddharth Agarwal <sid0@fb.com> parents: 32605 diff changeset	403
e696f597d02f dirstate: add docstring for invalidate Siddharth Agarwal <sid0@fb.com> parents: 32605 diff changeset	404 This is different from localrepo.invalidatedirstate() because it always
e696f597d02f dirstate: add docstring for invalidate Siddharth Agarwal <sid0@fb.com> parents: 32605 diff changeset	405 rereads the dirstate. Use localrepo.invalidatedirstate() if you want to
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	406 check whether the dirstate has changed before rereading it."""
32682 e696f597d02f dirstate: add docstring for invalidate Siddharth Agarwal <sid0@fb.com> parents: 32605 diff changeset	407
43503 313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings Augie Fackler <augie@google.com> parents: 43456 diff changeset	408 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	409 if a in self.__dict__:
6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4952 diff changeset	410 delattr(self, a)
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15670 diff changeset	411 self._lastnormaltime = 0
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	412 self._dirty = False
31206 49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	413 self._updatedfiles.clear()
22404 12bc7f06fc41 dirstate: add begin/endparentchange to dirstate Durham Goode <durham@fb.com> parents: 21984 diff changeset	414 self._parentwriters = 0
29772 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	415 self._origpl = None
4375 109077e7048d When reloading the dirstate, recompute ignore information if needed. Bryan O'Sullivan <bos@serpentine.com> parents: 4374 diff changeset	416
363 ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	417 def copy(self, source, dest):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	418 """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	419 if source == dest:
deda205a00e1 Ignore dummy copies in dirstate and localrepo.filecommit() Patrick Mezard <pmezard@gmail.com> parents: 6479 diff changeset	420 return
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	421 self._dirty = True
7566 5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441) Patrick Mezard <pmezard@gmail.com> parents: 7280 diff changeset	422 if source is not None:
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	423 self._map.copymap[dest] = source
31206 49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	424 self._updatedfiles.add(source)
49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	425 self._updatedfiles.add(dest)
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	426 elif self._map.copymap.pop(dest, None):
31206 49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	427 self._updatedfiles.add(dest)
363 ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	428
ae96b7e1318d Add hg copy mpm@selenic.com parents: 360 diff changeset	429 def copied(self, file):
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	430 return self._map.copymap.get(file, None)
3154 b1f10d3223c1 dirstate: add copies function Matt Mackall <mpm@selenic.com> parents: 2962 diff changeset	431
b1f10d3223c1 dirstate: add copies function Matt Mackall <mpm@selenic.com> parents: 2962 diff changeset	432 def copies(self):
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	433 return self._map.copymap
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 514 diff changeset	434
17196 2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath() Adrian Buehlmann <adrian@cadifra.com> parents: 17094 diff changeset	435 def _addpath(self, f, state, mode, size, mtime):
5487 7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660). Maxim Dounin <mdounin@mdounin.ru> parents: 5396 diff changeset	436 oldstate = self[f]
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	437 if state == b'a' or oldstate == b'r':
13974 23f2736abce3 move checkfilename from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13944 diff changeset	438 scmutil.checkfilename(f)
35084 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	439 if self._map.hastrackeddir(f):
47480 f93298a48da1 dirstate: split a not-so-one-liner Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47479 diff changeset	440 msg = _(b'directory %r already in dirstate')
f93298a48da1 dirstate: split a not-so-one-liner Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47479 diff changeset	441 msg %= pycompat.bytestr(f)
f93298a48da1 dirstate: split a not-so-one-liner Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47479 diff changeset	442 raise error.Abort(msg)
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	443 # shadows
43633 0b7733719d21 utils: move finddirs() to pathutil Martin von Zweigbergk <martinvonz@google.com> parents: 43620 diff changeset	444 for d in pathutil.finddirs(f):
35084 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	445 if self._map.hastrackeddir(d):
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	446 break
34188 1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	447 entry = self._map.get(d)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	448 if entry is not None and entry[0] != b'r':
47481 612f5f36fcf6 dirstate: split a not-so-one-liner Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47480 diff changeset	449 msg = _(b'file %r in dirstate clashes with %r')
612f5f36fcf6 dirstate: split a not-so-one-liner Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47480 diff changeset	450 msg %= (pycompat.bytestr(d), pycompat.bytestr(f))
612f5f36fcf6 dirstate: split a not-so-one-liner Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47480 diff changeset	451 raise error.Abort(msg)
17094 c2016bae3b97 dirstate: factor common update code into _addpath Joshua Redstone <joshua.redstone@fb.com> parents: 16955 diff changeset	452 self._dirty = True
31206 49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	453 self._updatedfiles.add(f)
35081 a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap Mark Thomas <mbthomas@fb.com> parents: 35080 diff changeset	454 self._map.addfile(f, oldstate, state, mode, size, mtime)
5487 7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660). Maxim Dounin <mdounin@mdounin.ru> parents: 5396 diff changeset	455
42456 87a34c767384 merge: fix race that could cause wrong size in dirstate Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42452 diff changeset	456 def normal(self, f, parentfiledata=None):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	457 """Mark a file normal and clean.
42456 87a34c767384 merge: fix race that could cause wrong size in dirstate Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42452 diff changeset	458
87a34c767384 merge: fix race that could cause wrong size in dirstate Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42452 diff changeset	459 parentfiledata: (mode, size, mtime) of the clean file
87a34c767384 merge: fix race that could cause wrong size in dirstate Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42452 diff changeset	460
87a34c767384 merge: fix race that could cause wrong size in dirstate Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42452 diff changeset	461 parentfiledata should be computed from memory (for mode,
87a34c767384 merge: fix race that could cause wrong size in dirstate Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42452 diff changeset	462 size), as or close as possible from the point where we
87a34c767384 merge: fix race that could cause wrong size in dirstate Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42452 diff changeset	463 determined the file was clean, to limit the risk of the
87a34c767384 merge: fix race that could cause wrong size in dirstate Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42452 diff changeset	464 file having been changed by an external process between the
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	465 moment where the file was determined to be clean and now."""
42456 87a34c767384 merge: fix race that could cause wrong size in dirstate Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42452 diff changeset	466 if parentfiledata:
87a34c767384 merge: fix race that could cause wrong size in dirstate Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42452 diff changeset	467 (mode, size, mtime) = parentfiledata
87a34c767384 merge: fix race that could cause wrong size in dirstate Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42452 diff changeset	468 else:
87a34c767384 merge: fix race that could cause wrong size in dirstate Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42452 diff changeset	469 s = os.lstat(self._join(f))
87a34c767384 merge: fix race that could cause wrong size in dirstate Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42452 diff changeset	470 mode = s.st_mode
87a34c767384 merge: fix race that could cause wrong size in dirstate Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42452 diff changeset	471 size = s.st_size
87a34c767384 merge: fix race that could cause wrong size in dirstate Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42452 diff changeset	472 mtime = s[stat.ST_MTIME]
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	473 self._addpath(f, b'n', mode, size & _rangemask, mtime & _rangemask)
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	474 self._map.copymap.pop(f, None)
34674 60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	475 if f in self._map.nonnormalset:
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	476 self._map.nonnormalset.remove(f)
13763 7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	477 if mtime > self._lastnormaltime:
7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	478 # Remember the most recent modification timeslot for status(),
13754 ae157ca56cd5 dirstate: check mtime when adding to _lastnormal Adrian Buehlmann <adrian@cadifra.com> parents: 13743 diff changeset	479 # to make sure we won't miss future size-preserving file content
ae157ca56cd5 dirstate: check mtime when adding to _lastnormal Adrian Buehlmann <adrian@cadifra.com> parents: 13743 diff changeset	480 # modifications that happen within the same timeslot.
13763 7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	481 self._lastnormaltime = mtime
13704 a464763e99f1 dirstate: avoid a race with multiple commits in the same process Greg Ward <greg@gerg.ca> parents: 13400 diff changeset	482
5210 90d9ec0dc69d merge: forcefully mark files that we get from the second parent as dirty Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5123 diff changeset	483 def normallookup(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	484 '''Mark a file normal, but possibly dirty.'''
47012 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	485 if self._pl[1] != self._nodeconstants.nullid:
6298 53cbb33e1269 normallookup: during merges, restore the state saved by remove Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6297 diff changeset	486 # if there is a merge going on and the file was either
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	487 # in state 'm' (-1) or coming from other parent (-2) before
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	488 # being removed, restore that state.
34188 1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	489 entry = self._map.get(f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	490 if entry is not None:
47482 cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47481 diff changeset	491 if entry[0] == b'r' and entry[2] in (-1, FROM_P2):
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	492 source = self._map.copymap.get(f)
34188 1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	493 if entry[2] == -1:
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	494 self.merge(f)
47482 cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47481 diff changeset	495 elif entry[2] == FROM_P2:
34188 1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	496 self.otherparent(f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	497 if source:
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	498 self.copy(source, f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	499 return
47482 cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47481 diff changeset	500 if entry[0] == b'm' or entry[0] == b'n' and entry[2] == FROM_P2:
34188 1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	501 return
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	502 self._addpath(f, b'n', 0, -1, -1)
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	503 self._map.copymap.pop(f, None)
5210 90d9ec0dc69d merge: forcefully mark files that we get from the second parent as dirty Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5123 diff changeset	504
10968 7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	505 def otherparent(self, f):
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent() Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10935 diff changeset	506 '''Mark as coming from the other parent, always dirty.'''
47012 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	507 if self._pl[1] == self._nodeconstants.nullid:
47479 e6b303eb8f7d dirstate: split a not-so-one-liner Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47477 diff changeset	508 msg = _(b"setting %r to other parent only allowed in merges") % f
e6b303eb8f7d dirstate: split a not-so-one-liner Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47477 diff changeset	509 raise error.Abort(msg)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	510 if f in self and self[f] == b'n':
22896 7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	511 # merge-like
47482 cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47481 diff changeset	512 self._addpath(f, b'm', 0, FROM_P2, -1)
22896 7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	513 else:
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity Matt Mackall <mpm@selenic.com> parents: 22895 diff changeset	514 # add-like
47482 cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47481 diff changeset	515 self._addpath(f, b'n', 0, FROM_P2, -1)
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	516 self._map.copymap.pop(f, None)
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	517
6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	518 def add(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	519 '''Mark a file added.'''
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	520 self._addpath(f, b'a', 0, -1, -1)
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	521 self._map.copymap.pop(f, None)
4616 70352337934e dirstate: refactor checkinterfering Matt Mackall <mpm@selenic.com> parents: 4615 diff changeset	522
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	523 def remove(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	524 '''Mark a file removed.'''
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	525 self._dirty = True
35081 a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap Mark Thomas <mbthomas@fb.com> parents: 35080 diff changeset	526 oldstate = self[f]
6297 fed1a9c22076 dirstate.remove: during merges, remember the previous file state Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 6257 diff changeset	527 size = 0
47012 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	528 if self._pl[1] != self._nodeconstants.nullid:
34188 1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	529 entry = self._map.get(f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	530 if entry is not None:
1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	531 # backup the previous state
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	532 if entry[0] == b'm': # merge
34188 1246acdad653 dirstate: perform transactions with _map using single call, where possible Michael Bolin <mbolin@fb.com> parents: 34022 diff changeset	533 size = -1
47482 cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47481 diff changeset	534 elif entry[0] == b'n' and entry[2] == FROM_P2: # other parent
cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47481 diff changeset	535 size = FROM_P2
34674 60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	536 self._map.otherparentset.add(f)
35083 e8ae0b2d88a8 dirstate: remove _droppath method Mark Thomas <mbthomas@fb.com> parents: 35082 diff changeset	537 self._updatedfiles.add(f)
35081 a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap Mark Thomas <mbthomas@fb.com> parents: 35080 diff changeset	538 self._map.removefile(f, oldstate, size)
33981 5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible Michael Bolin <mbolin@fb.com> parents: 33737 diff changeset	539 if size == 0:
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	540 self._map.copymap.pop(f, None)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	541
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	542 def merge(self, f):
10145 aec936051734 dirstate: improve docstring formatting Martin Geisler <mg@lazybytes.net> parents: 9678 diff changeset	543 '''Mark a file merged.'''
47012 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	544 if self._pl[1] == self._nodeconstants.nullid:
16509 eab9119c5dee rebase: skip resolved but emptied revisions Patrick Mezard <patrick@mezard.eu> parents: 16472 diff changeset	545 return self.normallookup(f)
22897 8fe74328f700 dirstate: merge falls through to otherparent Matt Mackall <mpm@selenic.com> parents: 22896 diff changeset	546 return self.otherparent(f)
4904 6fd953d5faea dirstate: break update into separate functions Matt Mackall <mpm@selenic.com> parents: 4903 diff changeset	547
14434 cc8c09855d19 dirstate: rename forget to drop Matt Mackall <mpm@selenic.com> parents: 14273 diff changeset	548 def drop(self, f):
cc8c09855d19 dirstate: rename forget to drop Matt Mackall <mpm@selenic.com> parents: 14273 diff changeset	549 '''Drop a file from the dirstate'''
35081 a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap Mark Thomas <mbthomas@fb.com> parents: 35080 diff changeset	550 oldstate = self[f]
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap Mark Thomas <mbthomas@fb.com> parents: 35080 diff changeset	551 if self._map.dropfile(f, oldstate):
15399 41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080) Matt Mackall <mpm@selenic.com> parents: 15337 diff changeset	552 self._dirty = True
35083 e8ae0b2d88a8 dirstate: remove _droppath method Mark Thomas <mbthomas@fb.com> parents: 35082 diff changeset	553 self._updatedfiles.add(f)
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	554 self._map.copymap.pop(f, None)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	555
24538 24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	556 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	557 if exists is None:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	558 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	559 if not exists:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	560 # Maybe a path component exists
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	561 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	562 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	563 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	564 folded = d + b"/" + f
24538 24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	565 else:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	566 # No path components, preserve original case
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	567 folded = path
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	568 else:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	569 # recursively normalize leading directory components
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	570 # against dirstate
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	571 if b'/' in normed:
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	572 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	573 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	574 r = self._root + b"/" + d
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	575 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	576 else:
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	577 folded = util.fspath(normed, self._root)
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	578 storemap[normed] = folded
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	579
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	580 return folded
24df92075200 dirstate: factor out code to discover normalized path Siddharth Agarwal <sid0@fb.com> parents: 24523 diff changeset	581
24539 3a8eba78803e dirstate: introduce function to normalize just filenames Siddharth Agarwal <sid0@fb.com> parents: 24538 diff changeset	582 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	583 normed = util.normcase(path)
34676 bfddc3d678ae dirstate: remove _filefoldmap property cache Durham Goode <durham@fb.com> parents: 34675 diff changeset	584 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	585 if folded is None:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	586 if isknown:
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	587 folded = path
7068 57377fa7eda2 issue 1286: dirstat regression on case folding systems Petr Kodl <petrkodl@gmail.com> parents: 7034 diff changeset	588 else:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	589 folded = self._discoverpath(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	590 path, normed, ignoremissing, exists, self._map.filefoldmap
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	591 )
24539 3a8eba78803e dirstate: introduce function to normalize just filenames Siddharth Agarwal <sid0@fb.com> parents: 24538 diff changeset	592 return folded
16302 49b54f1ae053 dirstate: normalize case of directory components Matt Mackall <mpm@selenic.com> parents: 16258 diff changeset	593
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	594 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	595 normed = util.normcase(path)
34676 bfddc3d678ae dirstate: remove _filefoldmap property cache Durham Goode <durham@fb.com> parents: 34675 diff changeset	596 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	597 if folded is None:
34678 e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	598 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	599 if folded is None:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	600 if isknown:
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	601 folded = path
7068 57377fa7eda2 issue 1286: dirstat regression on case folding systems Petr Kodl <petrkodl@gmail.com> parents: 7034 diff changeset	602 else:
24540 25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories Siddharth Agarwal <sid0@fb.com> parents: 24539 diff changeset	603 # 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	604 # normalizefile calls don't start matching directories
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	605 folded = self._discoverpath(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	606 path, normed, ignoremissing, exists, self._map.dirfoldmap
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	607 )
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	608 return folded
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	609
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	610 def normalize(self, path, isknown=False, ignoremissing=False):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	611 """
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	612 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	613
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	614 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	615 disk, to avoid extra filesystem access.
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	616
e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	617 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	618 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	619 existing path components.
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	620
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	621 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	622
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	623 - 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	624 - version of name stored on disk
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	625 - version provided via command arguments
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	626 """
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	627
bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	628 if self._checkcase:
16542 e596a631210e dirstate: preserve path components case on renames (issue3402) Patrick Mezard <patrick@mezard.eu> parents: 16509 diff changeset	629 return self._normalize(path, isknown, ignoremissing)
13717 bc41d08a5ccc dirstate: introduce a public case normalizing method Matt Mackall <mpm@selenic.com> parents: 13400 diff changeset	630 return path
6677 9865e15febd0 Add a normalize() method to dirstate Paul Moore <p.f.moore@gmail.com> parents: 6675 diff changeset	631
5065 b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	632 def clear(self):
34933 0217f75b6e59 dirstate: move clear onto dirstatemap class Durham Goode <durham@fb.com> parents: 34678 diff changeset	633 self._map.clear()
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15670 diff changeset	634 self._lastnormaltime = 0
31206 49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	635 self._updatedfiles.clear()
5123 79373ec3f27d merge with crew-stable Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5045 5065 diff changeset	636 self._dirty = True
5065 b304c2496f52 dirstate: fix rebuild; add a test Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 4953 diff changeset	637
18760 e74704c33e24 strip: make --keep option not set all dirstate times to 0 Durham Goode <durham@fb.com> parents: 18663 diff changeset	638 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	639 if changedfiles is None:
27176 54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild Christian Delahousse <cdelahousse@fb.com> parents: 27016 diff changeset	640 # Rebuild entire dirstate
43891 7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	641 to_lookup = allfiles
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	642 to_drop = []
27176 54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild Christian Delahousse <cdelahousse@fb.com> parents: 27016 diff changeset	643 lastnormaltime = self._lastnormaltime
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild Christian Delahousse <cdelahousse@fb.com> parents: 27016 diff changeset	644 self.clear()
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild Christian Delahousse <cdelahousse@fb.com> parents: 27016 diff changeset	645 self._lastnormaltime = lastnormaltime
43891 7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	646 elif len(changedfiles) < 10:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	647 # 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: 43869 diff changeset	648 # large.
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	649 to_lookup = []
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	650 to_drop = []
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	651 for f in changedfiles:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	652 if f in allfiles:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	653 to_lookup.append(f)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	654 else:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	655 to_drop.append(f)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	656 else:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	657 changedfilesset = set(changedfiles)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	658 to_lookup = changedfilesset & set(allfiles)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	659 to_drop = changedfilesset - to_lookup
27176 54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild Christian Delahousse <cdelahousse@fb.com> parents: 27016 diff changeset	660
29772 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	661 if self._origpl is None:
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	662 self._origpl = self._pl
47012 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	663 self._map.setparents(parent, self._nodeconstants.nullid)
43891 7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	664
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	665 for f in to_lookup:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	666 self.normallookup(f)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	667 for f in to_drop:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths Kyle Lippincott <spectral@google.com> parents: 43869 diff changeset	668 self.drop(f)
30026 ba06562a06a2 dirstate: rebuild should update dirstate properly Mateusz Kwapich <mitrandir@fb.com> parents: 29889 diff changeset	669
4903 81078e177266 dirstate: use True and false for _dirty Matt Mackall <mpm@selenic.com> parents: 4677 diff changeset	670 self._dirty = True
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	671
32750 b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32682 diff changeset	672 def identity(self):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	673 """Return identity of dirstate itself to detect changing in storage
32750 b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32682 diff changeset	674
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32682 diff changeset	675 If identity of previous dirstate is equal to this, writing
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32682 diff changeset	676 changes based on the former dirstate out can keep consistency.
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	677 """
34675 c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	678 return self._map.identity
32750 b698921ee137 dirstate: add identity information to detect simultaneous changing in storage FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32682 diff changeset	679
29673 52ff07e1de91 deprecation: enforce thew 'tr' argument of 'dirstate.write' (API) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 29351 diff changeset	680 def write(self, tr):
4612 17ee7407097f dirstate: simplify dirty handling Matt Mackall <mpm@selenic.com> parents: 4611 diff changeset	681 if not self._dirty:
1794 98b6c1cad58b only write the dirstate when something changed Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1755 diff changeset	682 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	683
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	684 filename = self._filename
29673 52ff07e1de91 deprecation: enforce thew 'tr' argument of 'dirstate.write' (API) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 29351 diff changeset	685 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	686 # '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	687 # 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	688 # 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	689 # 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	690 # 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	691
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	692 # emulate dropping timestamp in 'parsers.pack_dirstate'
26747 beff0b2481b3 dirstate: remove layering violation around writing dirstate out FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26746 diff changeset	693 now = _getfsnow(self._opener)
35080 19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	694 self._map.clearambiguoustimes(self._updatedfiles, now)
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	695
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	696 # emulate that all 'dirstate.normal' results are written out
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	697 self._lastnormaltime = 0
31206 49e5491ed9bd dirstate: track updated files to improve write time Durham Goode <durham@fb.com> parents: 31050 diff changeset	698 self._updatedfiles.clear()
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	699
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	700 # delay writing in-memory changes out
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	701 tr.addfilegenerator(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	702 b'dirstate',
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	703 (self._filename,),
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	704 self._writedirstate,
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	705 location=b'plain',
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	706 )
26634 09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	707 return
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26633 diff changeset	708
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	709 st = self._opener(filename, b"w", atomictemp=True, checkambig=True)
26521 3f41e28a16d8 dirstate: split write to write changes into files other than .hg/dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26492 diff changeset	710 self._writedirstate(st)
3f41e28a16d8 dirstate: split write to write changes into files other than .hg/dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26492 diff changeset	711
29772 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	712 def addparentchangecallback(self, category, callback):
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	713 """add a callback to be called when the wd parents are changed
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	714
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	715 Callback will be called with the following arguments:
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	716 dirstate, (oldp1, oldp2), (newp1, newp2)
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	717
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	718 Category is a unique identifier to allow overwriting an old callback
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	719 with a newer callback.
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	720 """
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	721 self._plchangecallbacks[category] = callback
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	722
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	723 def _writedirstate(self, st):
29772 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	724 # notify callbacks about parents change
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	725 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	726 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	727 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	728 ):
29772 2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	729 callback(self, self._origpl, self._pl)
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change Mateusz Kwapich <mitrandir@fb.com> parents: 29673 diff changeset	730 self._origpl = None
9509 e4ca8c258d9b dirstate: kill dirstate.granularity config option Adrian Buehlmann <adrian@cadifra.com> parents: 9379 diff changeset	731 # use the modification time of the newly created temporary file as the
e4ca8c258d9b dirstate: kill dirstate.granularity config option Adrian Buehlmann <adrian@cadifra.com> parents: 9379 diff changeset	732 # filesystem's notion of 'now'
36781 ffa3026d4196 cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime Augie Fackler <augie@google.com> parents: 36622 diff changeset	733 now = util.fstat(st)[stat.ST_MTIME] & _rangemask
27397 6c6b48aca328 dirstate: move delaywrite logic from write to _write Matt Mackall <mpm@selenic.com> parents: 27176 diff changeset	734
6c6b48aca328 dirstate: move delaywrite logic from write to _write Matt Mackall <mpm@selenic.com> parents: 27176 diff changeset	735 # 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	736 # 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	737 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	738 if delaywrite > 0:
27398 c81675776c95 dirstate: only invoke delaywrite if relevant Matt Mackall <mpm@selenic.com> parents: 27397 diff changeset	739 # do we have any files to delay for?
43425 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43281 diff changeset	740 for f, e in pycompat.iteritems(self._map):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	741 if e[0] == b'n' and e[3] == now:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	742 import time # to avoid useless import
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	743
27399 425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds Matt Mackall <mpm@selenic.com> parents: 27398 diff changeset	744 # 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	745 # 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	746 clock = time.time()
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds Matt Mackall <mpm@selenic.com> parents: 27398 diff changeset	747 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	748 end = start + delaywrite
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds Matt Mackall <mpm@selenic.com> parents: 27398 diff changeset	749 time.sleep(end - clock)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	750 now = end # trust our estimate that the end is near now
27398 c81675776c95 dirstate: only invoke delaywrite if relevant Matt Mackall <mpm@selenic.com> parents: 27397 diff changeset	751 break
27397 6c6b48aca328 dirstate: move delaywrite logic from write to _write Matt Mackall <mpm@selenic.com> parents: 27176 diff changeset	752
34673 e2214632c3a2 dirstate: move write into dirstatemap Durham Goode <durham@fb.com> parents: 34672 diff changeset	753 self._map.write(st, now)
21026 7ee03e190c1d dirstate: inline local finish function Mads Kiilerich <madski@unity3d.com> parents: 20632 diff changeset	754 self._lastnormaltime = 0
34673 e2214632c3a2 dirstate: move write into dirstatemap Durham Goode <durham@fb.com> parents: 34672 diff changeset	755 self._dirty = False
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	756
6032 b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	757 def _dirignore(self, f):
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	758 if self._ignore(f):
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	759 return True
43633 0b7733719d21 utils: move finddirs() to pathutil Martin von Zweigbergk <martinvonz@google.com> parents: 43620 diff changeset	760 for p in pathutil.finddirs(f):
6767 80605a8127e0 dirstate: simplify/optimize path checking Matt Mackall <mpm@selenic.com> parents: 6762 diff changeset	761 if self._ignore(p):
6032 b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	762 return True
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	763 return False
b41f0d6a74fc dirstate: don't walk ignored directories Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5516 diff changeset	764
27594 0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	765 def _ignorefiles(self):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	766 files = []
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	767 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	768 files.append(self._join(b'.hgignore'))
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	769 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	770 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	771 # 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	772 # 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	773 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	774 return files
0921caca7703 dirstate: extract logic to compute the list of ignorefiles Laurent Charignon <lcharignon@fb.com> parents: 27593 diff changeset	775
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	776 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	777 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	778 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	779 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	780 i = files.popleft()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	781 patterns = matchmod.readpatternfile(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	782 i, self._ui.warn, sourceinfo=True
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	783 )
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	784 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	785 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	786 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	787 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	788 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	789 continue
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	790 m = matchmod.match(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	791 self._root, b'', [], [pattern], warn=self._ui.warn
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	792 )
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	793 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	794 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	795 visited.add(i)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	796 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	797
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	798 def _walkexplicit(self, match, subrepos):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	799 """Get stat data about the files explicitly specified by match.
3529 09d99b7e4da0 simplify dirstate walking Matt Mackall <mpm@selenic.com> parents: 3223 diff changeset	800
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	801 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	802 - 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	803 listings mapping subrepos and .hg to None.
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	804 - 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	805 - dirsnotfound is a list of files that the dirstate thinks are
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	806 directories and that were not found."""
6578 f242d3684f83 walk: begin refactoring badmatch handling Matt Mackall <mpm@selenic.com> parents: 6577 diff changeset	807
8681 26f133267cd7 walk: use match.bad callback for filetype messages Matt Mackall <mpm@selenic.com> parents: 8680 diff changeset	808 def badtype(mode):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	809 kind = _(b'unknown')
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	810 if stat.S_ISCHR(mode):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	811 kind = _(b'character device')
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	812 elif stat.S_ISBLK(mode):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	813 kind = _(b'block device')
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	814 elif stat.S_ISFIFO(mode):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	815 kind = _(b'fifo')
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	816 elif stat.S_ISSOCK(mode):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	817 kind = _(b'socket')
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	818 elif stat.S_ISDIR(mode):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	819 kind = _(b'directory')
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	820 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	821
8676 acd69fc201a5 walk: we always have a badfn Matt Mackall <mpm@selenic.com> parents: 8675 diff changeset	822 badfn = match.bad
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	823 dmap = self._map
5000 46facb73ba8b dirstate: localize a bunch of methods for findfiles Matt Mackall <mpm@selenic.com> parents: 4965 diff changeset	824 lstat = os.lstat
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	825 getkind = stat.S_IFMT
6828 55d65a33da52 dirstate.walk: minor cleanups Matt Mackall <mpm@selenic.com> parents: 6827 diff changeset	826 dirkind = stat.S_IFDIR
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	827 regkind = stat.S_IFREG
2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	828 lnkkind = stat.S_IFLNK
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	829 join = self._join
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	830 dirsfound = []
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	831 foundadd = dirsfound.append
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	832 dirsnotfound = []
19175 63f7bd2e1a46 dirstate._walkexplicit: inline dirsnotfound.append Siddharth Agarwal <sid0@fb.com> parents: 19174 diff changeset	833 notfoundadd = dirsnotfound.append
6820 639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	834
24448 55c449345b10 match: add isexact() method to hide internals Martin von Zweigbergk <martinvonz@google.com> parents: 24212 diff changeset	835 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	836 normalize = self._normalize
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440) Matt Mackall <mpm@selenic.com> parents: 12401 diff changeset	837 else:
18032 a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda Siddharth Agarwal <sid0@fb.com> parents: 18018 diff changeset	838 normalize = None
12907 e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440) Matt Mackall <mpm@selenic.com> parents: 12401 diff changeset	839
12211 798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	840 files = sorted(match.files())
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	841 subrepos.sort()
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	842 i, j = 0, 0
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	843 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	844 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	845 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	846 i += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	847 continue
13339 22167be007ed subrepo: fix pruning of subrepo filenames in dirstate (issue2619) trbs <trbs@trbs.net> parents: 13233 diff changeset	848 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	849 del files[i]
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	850 j += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	851
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	852 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	853 files = [b'']
42340 7ada598941d2 dirstate: move special handling of files==['.'] together Martin von Zweigbergk <martinvonz@google.com> parents: 42304 diff changeset	854 # constructing the foldmap is expensive, so don't do it for the
42341 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42340 diff changeset	855 # common case where files is ['']
42340 7ada598941d2 dirstate: move special handling of files==['.'] together Martin von Zweigbergk <martinvonz@google.com> parents: 42304 diff changeset	856 normalize = None
10176 24ce8f0c0a39 dirstate: don't check state of subrepo directories Augie Fackler <durin42@gmail.com> parents: 10145 diff changeset	857 results = dict.fromkeys(subrepos)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	858 results[b'.hg'] = None
5000 46facb73ba8b dirstate: localize a bunch of methods for findfiles Matt Mackall <mpm@selenic.com> parents: 4965 diff changeset	859
12211 798d72f3621c dirstate: use one pass to filter out files in subrepos Martin Geisler <mg@lazybytes.net> parents: 12164 diff changeset	860 for ff in files:
42340 7ada598941d2 dirstate: move special handling of files==['.'] together Martin von Zweigbergk <martinvonz@google.com> parents: 42304 diff changeset	861 if normalize:
24522 18085e46caa9 dirstate._walkexplicit: drop normpath calls Siddharth Agarwal <sid0@fb.com> parents: 24521 diff changeset	862 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	863 else:
24522 18085e46caa9 dirstate._walkexplicit: drop normpath calls Siddharth Agarwal <sid0@fb.com> parents: 24521 diff changeset	864 nf = ff
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	865 if nf in results:
6820 639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	866 continue
639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	867
639d9cb95509 dirstate.walk: fold findfiles into main walk loop Matt Mackall <mpm@selenic.com> parents: 6819 diff changeset	868 try:
6831 2b663f542bd3 dirstate.walk: more cleanups Matt Mackall <mpm@selenic.com> parents: 6830 diff changeset	869 st = lstat(join(nf))
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	870 kind = getkind(st.st_mode)
2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	871 if kind == dirkind:
8588 2624f485b9bc dirstate: set more states in step 1 of walk Simon Heimberg <simohe@besonet.ch> parents: 8521 diff changeset	872 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	873 # 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	874 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	875 foundadd((nf, ff))
12401 4cdaf1adafc8 backout most of 4f8067c94729 Matt Mackall <mpm@selenic.com> parents: 12387 diff changeset	876 elif kind == regkind or kind == lnkkind:
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	877 results[nf] = st
6828 55d65a33da52 dirstate.walk: minor cleanups Matt Mackall <mpm@selenic.com> parents: 6827 diff changeset	878 else:
8681 26f133267cd7 walk: use match.bad callback for filetype messages Matt Mackall <mpm@selenic.com> parents: 8680 diff changeset	879 badfn(ff, badtype(kind))
6830 2cf4cda64727 dirstate.walk: fold in _supported Matt Mackall <mpm@selenic.com> parents: 6829 diff changeset	880 if nf in dmap:
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	881 results[nf] = None
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	882 except OSError as inst: # nf not found on disk - it is dirstate only
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	883 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	884 results[nf] = None
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	885 else: # does it match a missing directory?
35084 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	886 if self._map.hasdir(nf):
23375 a179db3db9b9 dirstate: speed up repeated missing directory checks Martin von Zweigbergk <martinvonz@google.com> parents: 22915 diff changeset	887 notfoundadd(nf)
8677 34df078b8b1b walk: simplify logic for badfn clause Matt Mackall <mpm@selenic.com> parents: 8676 diff changeset	888 else:
34022 d5b2beca16c0 python3: wrap all uses of <exception>.strerror with strtolocal Augie Fackler <raf@durin42.com> parents: 33981 diff changeset	889 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	890
36200 deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35895 diff changeset	891 # 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: 35895 diff changeset	892 # 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: 35895 diff changeset	893 # 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: 35895 diff changeset	894 if match.anypats():
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35895 diff changeset	895 for f in list(results):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	896 if f == b'.hg' or f in subrepos:
36200 deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35895 diff changeset	897 # 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: 35895 diff changeset	898 continue
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35895 diff changeset	899 if not match(f):
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35895 diff changeset	900 del results[f]
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679) Yuya Nishihara <yuya@tcha.org> parents: 35895 diff changeset	901
25877 85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	902 # 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	903 # 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	904 # 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	905 # 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	906 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	907 normed = {}
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	908
43106 d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43090 diff changeset	909 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	910 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	911 continue
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	912
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	913 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	914 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	915
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	916 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	917 paths = set()
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	918 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	919
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	920 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	921
43106 d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43090 diff changeset	922 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	923 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	924 for path in paths:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	925 folded = self._discoverpath(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	926 path, norm, True, None, self._map.dirfoldmap
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	927 )
25877 85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760) Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	928 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	929 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	930
19174 022256ef47b8 dirstate._walkexplicit: rename work to dirsfound Siddharth Agarwal <sid0@fb.com> parents: 19173 diff changeset	931 return results, dirsfound, dirsnotfound
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	932
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	933 def walk(self, match, subrepos, unknown, ignored, full=True):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	934 """
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	935 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	936 matched by match.
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	937
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	938 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	939
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	940 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	941 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	942
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	943 """
19190 b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks Siddharth Agarwal <sid0@fb.com> parents: 19175 diff changeset	944 # 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	945 # 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	946 # 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	947
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	948 if ignored:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	949 ignore = util.never
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	950 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	951 elif unknown:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	952 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	953 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	954 else:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	955 # 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	956 ignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	957 dirignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	958
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	959 matchfn = match.matchfn
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	960 matchalways = match.always()
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	961 matchtdir = match.traversedir
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	962 dmap = self._map
32208 d74b0cff94a9 osutil: proxy through util (and platform) modules (API) Yuya Nishihara <yuya@tcha.org> parents: 32177 diff changeset	963 listdir = util.listdir
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	964 lstat = os.lstat
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	965 dirkind = stat.S_IFDIR
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	966 regkind = stat.S_IFREG
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	967 lnkkind = stat.S_IFLNK
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	968 join = self._join
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	969
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	970 exact = skipstep3 = False
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	971 if match.isexact(): # match.exact
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	972 exact = True
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	973 dirignore = util.always # skip step 2
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	974 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	975 skipstep3 = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	976
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	977 if not exact and self._checkcase:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	978 normalize = self._normalize
24541 e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize Siddharth Agarwal <sid0@fb.com> parents: 24540 diff changeset	979 normalizefile = self._normalizefile
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	980 skipstep3 = False
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	981 else:
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	982 normalize = self._normalize
24541 e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize Siddharth Agarwal <sid0@fb.com> parents: 24540 diff changeset	983 normalizefile = None
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	984
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	985 # step 1: find all explicit files
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	986 results, work, dirsnotfound = self._walkexplicit(match, subrepos)
43713 95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls Martin von Zweigbergk <martinvonz@google.com> parents: 43696 diff changeset	987 if matchtdir:
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls Martin von Zweigbergk <martinvonz@google.com> parents: 43696 diff changeset	988 for d in work:
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls Martin von Zweigbergk <martinvonz@google.com> parents: 43696 diff changeset	989 matchtdir(d[0])
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls Martin von Zweigbergk <martinvonz@google.com> parents: 43696 diff changeset	990 for d in dirsnotfound:
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls Martin von Zweigbergk <martinvonz@google.com> parents: 43696 diff changeset	991 matchtdir(d)
19173 ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function Siddharth Agarwal <sid0@fb.com> parents: 19172 diff changeset	992
19172 c6cea2e2031b dirstate.walk: pull skipstep3 out of the explicit walk code Siddharth Agarwal <sid0@fb.com> parents: 19171 diff changeset	993 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	994 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	995
6826 eca20fee0728 dirstate.walk: pull directory scanning into top-level loop Matt Mackall <mpm@selenic.com> parents: 6825 diff changeset	996 # 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	997 def traverse(work, alreadynormed):
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	998 wadd = work.append
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	999 while work:
43239 6fcdcea2b03a dirstate: add some traces on listdir calls Augie Fackler <augie@google.com> parents: 43117 diff changeset	1000 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	1001 nd = work.pop()
38956 a3cabe9415e1 dirstate: use visitchildrenset in traverse Kyle Lippincott <spectral@google.com> parents: 36995 diff changeset	1002 visitentries = match.visitchildrenset(nd)
a3cabe9415e1 dirstate: use visitchildrenset in traverse Kyle Lippincott <spectral@google.com> parents: 36995 diff changeset	1003 if not visitentries:
32177 8f1a2b848b52 dirstate: optimize walk() by using match.visitdir() Martin von Zweigbergk <martinvonz@google.com> parents: 31547 diff changeset	1004 continue
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1005 if visitentries == b'this' or visitentries == b'all':
38956 a3cabe9415e1 dirstate: use visitchildrenset in traverse Kyle Lippincott <spectral@google.com> parents: 36995 diff changeset	1006 visitentries = None
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1007 skip = None
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1008 if nd != b'':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1009 skip = b'.hg'
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1010 try:
43239 6fcdcea2b03a dirstate: add some traces on listdir calls Augie Fackler <augie@google.com> parents: 43117 diff changeset	1011 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	1012 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	1013 except OSError as inst:
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1014 if inst.errno in (errno.EACCES, errno.ENOENT):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1015 match.bad(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1016 self.pathto(nd), encoding.strtolocal(inst.strerror)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1017 )
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1018 continue
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1019 raise
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1020 for f, kind, st in entries:
39260 27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38959 diff changeset	1021 # Some matchers may return files in the visitentries set,
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38959 diff changeset	1022 # instead of 'this', if the matcher explicitly mentions them
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38959 diff changeset	1023 # 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: 38959 diff changeset	1024 # make any hard assumptions about file-or-directory below
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38959 diff changeset	1025 # based on the presence of `f` in visitentries. If
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38959 diff changeset	1026 # visitchildrenset returned a set, we can always skip the
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38959 diff changeset	1027 # entries not in the set it provided regardless of whether
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38959 diff changeset	1028 # they're actually a file or a directory.
38956 a3cabe9415e1 dirstate: use visitchildrenset in traverse Kyle Lippincott <spectral@google.com> parents: 36995 diff changeset	1029 if visitentries and f not in visitentries:
a3cabe9415e1 dirstate: use visitchildrenset in traverse Kyle Lippincott <spectral@google.com> parents: 36995 diff changeset	1030 continue
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1031 if normalizefile:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1032 # 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	1033 # 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	1034 # dmap -- therefore normalizefile is enough
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1035 nf = normalizefile(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1036 nd and (nd + b"/" + f) or f, True, True
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1037 )
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1038 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1039 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	1040 if nf not in results:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1041 if kind == dirkind:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1042 if not ignore(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1043 if matchtdir:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1044 matchtdir(nf)
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	1045 wadd(nf)
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1046 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	1047 results[nf] = None
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1048 elif kind == regkind or kind == lnkkind:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1049 if nf in dmap:
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1050 if matchalways or matchfn(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1051 results[nf] = st
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1052 elif (matchalways or matchfn(nf)) and not ignore(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1053 nf
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1054 ):
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	1055 # 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	1056 if not alreadynormed:
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	1057 nf = normalize(nf, False, True)
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1058 results[nf] = st
4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1059 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	1060 results[nf] = None
24559 4728d6f7c69f dirstate.walk: factor out directory traversal Siddharth Agarwal <sid0@fb.com> parents: 24553 diff changeset	1061
24560 b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	1062 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	1063 # 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	1064 # expensive directory normalization
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel Siddharth Agarwal <sid0@fb.com> parents: 24559 diff changeset	1065 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	1066 traverse([d], alreadynormed)
536 c15b4bc0a11c Refactor diffrevs/diffdir into changes mpm@selenic.com parents: 529 diff changeset	1067
18812 1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3 Siddharth Agarwal <sid0@fb.com> parents: 18792 diff changeset	1068 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	1069 del results[s]
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1070 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	1071
21115 1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker Mads Kiilerich <madski@unity3d.com> parents: 21026 diff changeset	1072 # 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	1073 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	1074 # 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	1075 # 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	1076 # 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	1077 if not results and matchalways:
31422 2e38a88bbc6c dirstate: use list comprehension to get a list of keys Pulkit Goyal <7895pulkit@gmail.com> parents: 31278 diff changeset	1078 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	1079 else:
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3 Siddharth Agarwal <sid0@fb.com> parents: 18814 diff changeset	1080 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	1081 visit.sort()
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3 Siddharth Agarwal <sid0@fb.com> parents: 18814 diff changeset	1082
18625 2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	1083 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	1084 # 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	1085 # 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	1086 # 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	1087 # The rest must thus be ignored or under a symlink.
33649 377e8ddaebef pathauditor: disable cache of audited paths by default (issue5628) Yuya Nishihara <yuya@tcha.org> parents: 33440 diff changeset	1088 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	1089
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	1090 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	1091 # 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	1092 # 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	1093 # 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	1094 # on disk.
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1095 if (
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1096 normalizefile
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1097 and normalizefile(nf, True, True) in results
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1098 ):
24621 1784ca148392 dirstate.walk: don't report same file stat multiple times Martin von Zweigbergk <martinvonz@google.com> parents: 24537 diff changeset	1099 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	1100 # 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	1101 # 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	1102 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	1103 try:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	1104 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	1105 # 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	1106 except OSError:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	1107 # file doesn't exist
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7 Durham Goode <durham@fb.com> parents: 18653 diff changeset	1108 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	1109 else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	1110 # 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	1111 # 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	1112 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	1113 else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path Durham Goode <durham@fb.com> parents: 18567 diff changeset	1114 # 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	1115 # so stat and check everything we missed.
31507 4d1dd9cf0dca dirstate: use future-proof next(iter) instead of iter.next Augie Fackler <augie@google.com> parents: 31422 diff changeset	1116 iv = iter(visit)
26984 af2663680e95 dirstate: back out 502b56a9e897 Bryan O'Sullivan <bos@serpentine.com> parents: 26887 diff changeset	1117 for st in util.statfiles([join(i) for i in visit]):
31507 4d1dd9cf0dca dirstate: use future-proof next(iter) instead of iter.next Augie Fackler <augie@google.com> parents: 31422 diff changeset	1118 results[next(iv)] = st
6829 fec1da46006e dirstate.walk: build a dict rather than yield Matt Mackall <mpm@selenic.com> parents: 6828 diff changeset	1119 return results
669 8aa2a282eda4 .hgignore speedups patch incorporating Matt's feedback. mwilli2@localhost.localdomain parents: 667 diff changeset	1120
44530 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1121 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: 43917 diff changeset	1122 # 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: 43917 diff changeset	1123 # 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: 43917 diff changeset	1124 # 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: 43917 diff changeset	1125 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: 43917 diff changeset	1126 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: 43917 diff changeset	1127 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: 43917 diff changeset	1128
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1129 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: 43917 diff changeset	1130 if not workers_enabled:
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1131 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: 43917 diff changeset	1132
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1133 (
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1134 lookup,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1135 modified,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1136 added,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1137 removed,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1138 deleted,
44530 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1139 clean,
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1140 ignored,
44078 f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1141 unknown,
44530 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1142 warnings,
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1143 bad,
44840 4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path Rapha?l Gom?s <rgomes@octobus.net> parents: 44836 diff changeset	1144 traversed,
47350 04d1f17f49e7 dirstate-v2: Write .hg/dirstate back to disk on directory cache changes Simon Sapin <simon.sapin@octobus.net> parents: 47320 diff changeset	1145 dirty,
44078 f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1146 ) = rustmod.status(
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1147 self._map._rustmap,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1148 matcher,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1149 self._rootdir,
44530 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1150 self._ignorefiles(),
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1151 self._checkexec,
44078 f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1152 self._lastnormaltime,
44530 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1153 bool(list_clean),
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1154 bool(list_ignored),
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1155 bool(list_unknown),
44840 4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path Rapha?l Gom?s <rgomes@octobus.net> parents: 44836 diff changeset	1156 bool(matcher.traversedir),
44078 f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1157 )
44840 4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path Rapha?l Gom?s <rgomes@octobus.net> parents: 44836 diff changeset	1158
47350 04d1f17f49e7 dirstate-v2: Write .hg/dirstate back to disk on directory cache changes Simon Sapin <simon.sapin@octobus.net> parents: 47320 diff changeset	1159 self._dirty \|= dirty
04d1f17f49e7 dirstate-v2: Write .hg/dirstate back to disk on directory cache changes Simon Sapin <simon.sapin@octobus.net> parents: 47320 diff changeset	1160
44840 4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path Rapha?l Gom?s <rgomes@octobus.net> parents: 44836 diff changeset	1161 if matcher.traversedir:
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path Rapha?l Gom?s <rgomes@octobus.net> parents: 44836 diff changeset	1162 for dir in traversed:
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path Rapha?l Gom?s <rgomes@octobus.net> parents: 44836 diff changeset	1163 matcher.traversedir(dir)
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path Rapha?l Gom?s <rgomes@octobus.net> parents: 44836 diff changeset	1164
44530 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1165 if self._ui.warn:
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1166 for item in warnings:
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1167 if isinstance(item, tuple):
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1168 file_path, syntax = item
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1169 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: 44357 diff changeset	1170 file_path,
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1171 syntax,
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1172 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1173 self._ui.warn(msg)
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1174 else:
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1175 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: 44357 diff changeset	1176 self._ui.warn(
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1177 msg
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1178 % (
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1179 pathutil.canonpath(
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1180 self._rootdir, self._rootdir, item
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1181 ),
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1182 b"No such file or directory",
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1183 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1184 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1185
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1186 for (fn, message) in bad:
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1187 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: 43917 diff changeset	1188
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1189 status = scmutil.status(
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1190 modified=modified,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1191 added=added,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1192 removed=removed,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1193 deleted=deleted,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1194 unknown=unknown,
44530 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1195 ignored=ignored,
44078 f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1196 clean=clean,
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1197 )
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1198 return (lookup, status)
f2c350e7371e dirstate: move rust fast-path calling code to its own method Rapha?l Gom?s <rgomes@octobus.net> parents: 43917 diff changeset	1199
10176 24ce8f0c0a39 dirstate: don't check state of subrepo directories Augie Fackler <durin42@gmail.com> parents: 10145 diff changeset	1200 def status(self, match, subrepos, ignored, clean, unknown):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	1201 """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	1202 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	1203 scmutil.status and:
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1204
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1205 unsure:
bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1206 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	1207 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	1208 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	1209 status.modified:
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1210 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	1211 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	1212 status.clean:
9518 bc19a0b04e83 dirstate: add/improve method docstrings. Greg Ward <greg-hg@gerg.ca> parents: 9509 diff changeset	1213 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	1214 dirstate was written
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	1215 """
6753 ed5ffb2c12f3 repo.status: eliminate list_ Matt Mackall <mpm@selenic.com> parents: 6750 diff changeset	1216 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	1217 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	1218 removed, deleted, clean = [], [], []
723 9e0f3ba4a9c2 Work on walk code. Bryan O'Sullivan <bos@serpentine.com> parents: 705 diff changeset	1219
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1220 dmap = self._map
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1221 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	1222
733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43239 diff changeset	1223 use_rust = True
43917 40fd1ef4e4c1 rust-matchers: add support for `exactmatcher` in `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43891 diff changeset	1224
44530 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1225 allowed_matchers = (
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1226 matchmod.alwaysmatcher,
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1227 matchmod.exactmatcher,
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1228 matchmod.includematcher,
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1229 )
43917 40fd1ef4e4c1 rust-matchers: add support for `exactmatcher` in `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43891 diff changeset	1230
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	1231 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	1232 use_rust = False
44530 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1233 elif self._checkcase:
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1234 # 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: 44357 diff changeset	1235 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	1236 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	1237 use_rust = False
44530 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1238 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	1239 use_rust = False
43917 40fd1ef4e4c1 rust-matchers: add support for `exactmatcher` in `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43891 diff changeset	1240 elif not isinstance(match, allowed_matchers):
44836 63edfea7dfde status: update comment to reflect the more recent situation Rapha?l Gom?s <rgomes@octobus.net> parents: 44801 diff changeset	1241 # 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	1242 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	1243
733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status` Rapha?l Gom?s <rgomes@octobus.net> parents: 43239 diff changeset	1244 if use_rust:
44530 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1245 try:
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1246 return self._rust_status(
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1247 match, listclean, listignored, listunknown
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1248 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1249 except rustmod.FallbackError:
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1250 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	1251
43620 dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API) Martin von Zweigbergk <martinvonz@google.com> parents: 43612 diff changeset	1252 def noop(f):
dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API) Martin von Zweigbergk <martinvonz@google.com> parents: 43612 diff changeset	1253 pass
dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API) Martin von Zweigbergk <martinvonz@google.com> parents: 43612 diff changeset	1254
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1255 dcontains = dmap.__contains__
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1256 dget = dmap.__getitem__
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1257 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	1258 madd = modified.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1259 aadd = added.append
43620 dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API) Martin von Zweigbergk <martinvonz@google.com> parents: 43612 diff changeset	1260 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: 43612 diff changeset	1261 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	1262 radd = removed.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1263 dadd = deleted.append
43620 dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API) Martin von Zweigbergk <martinvonz@google.com> parents: 43612 diff changeset	1264 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	1265 mexact = match.exact
1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1266 dirignore = self._dirignore
1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1267 checkexec = self._checkexec
34336 0865d25e8a8a dirstate: move _copymap to dirstatemap Durham Goode <durham@fb.com> parents: 34335 diff changeset	1268 copymap = self._map.copymap
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1269 lastnormaltime = self._lastnormaltime
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1270
19191 ab9de1e8fc36 dirstate.status: avoid full walks when possible Siddharth Agarwal <sid0@fb.com> parents: 19190 diff changeset	1271 # 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	1272 # - we're listing all clean files, or
ab9de1e8fc36 dirstate.status: avoid full walks when possible Siddharth Agarwal <sid0@fb.com> parents: 19190 diff changeset	1273 # - 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	1274 # 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	1275 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	1276 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	1277 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	1278 ):
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1279 if not dcontains(fn):
18034 1a570f04de07 dirstate: inline more properties and methods in status Siddharth Agarwal <sid0@fb.com> parents: 18032 diff changeset	1280 if (listignored or mexact(fn)) and dirignore(fn):
6753 ed5ffb2c12f3 repo.status: eliminate list_ Matt Mackall <mpm@selenic.com> parents: 6750 diff changeset	1281 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	1282 iadd(fn)
19910 601944f41257 dirstate.status: return explicit unknown files even when not asked Siddharth Agarwal <sid0@fb.com> parents: 19651 diff changeset	1283 else:
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1284 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	1285 continue
6591 eda3fd322a7f dirstate: minor status cleanups Matt Mackall <mpm@selenic.com> parents: 6590 diff changeset	1286
21810 4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1287 # This is equivalent to 'state, mode, size, time = dmap[fn]' but not
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1288 # written like that for performance reasons. dmap[fn] is not a
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1289 # Python tuple in compiled builds. The CPython UNPACK_SEQUENCE
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1290 # opcode has fast paths when the value to be unpacked is a tuple or
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1291 # a list, but falls back to creating a full-fledged iterator in
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1292 # general. That is much slower than simply accessing and storing the
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1293 # tuple members one by one.
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1294 t = dget(fn)
21810 4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1295 state = t[0]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1296 mode = t[1]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1297 size = t[2]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple Siddharth Agarwal <sid0@fb.com> parents: 21809 diff changeset	1298 time = t[3]
6591 eda3fd322a7f dirstate: minor status cleanups Matt Mackall <mpm@selenic.com> parents: 6590 diff changeset	1299
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1300 if not st and state in b"nma":
6818 6e93fbd847ef dirstate.walk: eliminate src from yield Matt Mackall <mpm@selenic.com> parents: 6811 diff changeset	1301 dadd(fn)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1302 elif state == b'n':
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1303 if (
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1304 size >= 0
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1305 and (
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1306 (size != st.st_size and size != st.st_size & _rangemask)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1307 or ((mode ^ st.st_mode) & 0o100 and checkexec)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1308 )
47482 cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47481 diff changeset	1309 or size == FROM_P2 # other parent
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1310 or fn in copymap
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1311 ):
46703 ca69e29a2a30 formatting: fix redundant parentheses Rapha?l Gom?s <rgomes@octobus.net> parents: 46678 diff changeset	1312 if stat.S_ISLNK(st.st_mode) and size != st.st_size:
46678 0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt Corey Schuhen <cschuhen@topcon.com> parents: 45942 diff changeset	1313 # 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: 45942 diff changeset	1314 # 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: 45942 diff changeset	1315 ladd(fn)
0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt Corey Schuhen <cschuhen@topcon.com> parents: 45942 diff changeset	1316 else:
0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt Corey Schuhen <cschuhen@topcon.com> parents: 45942 diff changeset	1317 madd(fn)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1318 elif (
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1319 time != st[stat.ST_MTIME]
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1320 and time != st[stat.ST_MTIME] & _rangemask
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1321 ):
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1322 ladd(fn)
36781 ffa3026d4196 cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime Augie Fackler <augie@google.com> parents: 36622 diff changeset	1323 elif st[stat.ST_MTIME] == lastnormaltime:
24181 5245caa0dcde dirstate: clarify comment about leaving normal files undef if changed 'now' Mads Kiilerich <madski@unity3d.com> parents: 23866 diff changeset	1324 # 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	1325 # 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	1326 # This can happen if we quickly do multiple commits.
13763 7a73c406c0fd dirstate: eliminate _lastnormal set Adrian Buehlmann <adrian@cadifra.com> parents: 13754 diff changeset	1327 # 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	1328 ladd(fn)
6753 ed5ffb2c12f3 repo.status: eliminate list_ Matt Mackall <mpm@selenic.com> parents: 6750 diff changeset	1329 elif listclean:
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1330 cadd(fn)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1331 elif state == b'm':
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1332 madd(fn)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1333 elif state == b'a':
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1334 aadd(fn)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1335 elif state == b'r':
5003 4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath Matt Mackall <mpm@selenic.com> parents: 5002 diff changeset	1336 radd(fn)
44530 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1337 status = scmutil.status(
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1338 modified, added, removed, deleted, unknown, ignored, clean
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1339 )
44530 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44357 diff changeset	1340 return (lookup, status)
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1341
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1342 def matches(self, match):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	1343 """
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1344 return files in the dirstate (in whatever state) filtered by match
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45243 diff changeset	1345 """
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1346 dmap = self._map
44357 bed8d08cfcb2 rust-dirstatemap: remove additional lookup in dirstate.matches Rapha?l Gom?s <rgomes@octobus.net> parents: 44297 diff changeset	1347 if rustmod is not None:
bed8d08cfcb2 rust-dirstatemap: remove additional lookup in dirstate.matches Rapha?l Gom?s <rgomes@octobus.net> parents: 44297 diff changeset	1348 dmap = self._map._rustmap
bed8d08cfcb2 rust-dirstatemap: remove additional lookup in dirstate.matches Rapha?l Gom?s <rgomes@octobus.net> parents: 44297 diff changeset	1349
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1350 if match.always():
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1351 return dmap.keys()
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1352 files = match.files()
24448 55c449345b10 match: add isexact() method to hide internals Martin von Zweigbergk <martinvonz@google.com> parents: 24212 diff changeset	1353 if match.isexact():
21984 977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1354 # 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	1355 # much smaller than dmap
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1356 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	1357 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	1358 # 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	1359 # that
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1360 return list(files)
977a0b9af5ac dirstate: add a method to efficiently filter by match Siddharth Agarwal <sid0@fb.com> parents: 21931 diff changeset	1361 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	1362
26746 3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26635 diff changeset	1363 def _actualfilename(self, tr):
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26635 diff changeset	1364 if tr:
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1365 return self._pendingfilename
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1366 else:
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1367 return self._filename
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1368
33440 ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1369 def savebackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1370 '''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	1371 filename = self._actualfilename(tr)
33440 ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1372 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	1373
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1374 # 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	1375 # 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	1376 # output file will be used to create backup of dirstate at this point.
31208 fc57a8b95f1b dirstate: avoid unnecessary load+dump during backup Jun Wu <quark@fb.com> parents: 31207 diff changeset	1377 if self._dirty or not self._opener.exists(filename):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1378 self._writedirstate(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1379 self._opener(filename, b"w", atomictemp=True, checkambig=True)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1380 )
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1381
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1382 if tr:
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1383 # 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	1384 # 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	1385 # changed after this
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1386 tr.addfilegenerator(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1387 b'dirstate',
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1388 (self._filename,),
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1389 self._writedirstate,
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1390 location=b'plain',
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1391 )
26633 020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1392
020b12d591f3 dirstate: make functions for backup aware of transaction activity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26632 diff changeset	1393 # 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	1394 # 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	1395 # end of this transaction
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1396 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	1397
31547 ddadb6b0b58e dirstate: use tryunlink Ryan McElroy <rmcelroy@fb.com> parents: 31507 diff changeset	1398 self._opener.tryunlink(backupname)
31207 1ef37b16b8e8 dirstate: try to use hardlink to backup dirstate Jun Wu <quark@fb.com> parents: 31206 diff changeset	1399 # hardlink backup is okay because _writedirstate is always called
1ef37b16b8e8 dirstate: try to use hardlink to backup dirstate Jun Wu <quark@fb.com> parents: 31206 diff changeset	1400 # with an "atomictemp=True" file.
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1401 util.copyfile(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1402 self._opener.join(filename),
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1403 self._opener.join(backupname),
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1404 hardlink=True,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1405 )
26632 59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26630 diff changeset	1406
33440 ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1407 def restorebackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1408 '''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	1409 # 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	1410 # 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	1411 self.invalidate()
26746 3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26635 diff changeset	1412 filename = self._actualfilename(tr)
34940 c2b30348930f dirstate: clean up when restoring identical backups Mark Thomas <mbthomas@fb.com> parents: 34935 diff changeset	1413 o = self._opener
c2b30348930f dirstate: clean up when restoring identical backups Mark Thomas <mbthomas@fb.com> parents: 34935 diff changeset	1414 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	1415 o.unlink(backupname)
c2b30348930f dirstate: clean up when restoring identical backups Mark Thomas <mbthomas@fb.com> parents: 34935 diff changeset	1416 else:
c2b30348930f dirstate: clean up when restoring identical backups Mark Thomas <mbthomas@fb.com> parents: 34935 diff changeset	1417 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	1418
33440 ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1419 def clearbackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1420 '''Clear backup file'''
ec306bc6915b dirstate: update backup functions to take full backup filename Adam Simpkins <simpkins@fb.com> parents: 33373 diff changeset	1421 self._opener.unlink(backupname)
34332 b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1422
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1423
34332 b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1424 class dirstatemap(object):
35078 a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1425 """Map encapsulating the dirstate's contents.
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1426
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1427 The dirstate contains the following state:
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1428
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1429 - `identity` is the identity of the dirstate file, which can be used to
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1430 detect when changes have occurred to the dirstate file.
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1431
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1432 - `parents` is a pair containing the parents of the working copy. The
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1433 parents are updated by calling `setparents`.
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1434
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1435 - the state map maps filenames to tuples of (state, mode, size, mtime),
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1436 where state is a single character representing 'normal', 'added',
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1437 'removed', or 'merged'. It is read by treating the dirstate as a
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1438 dict. File state is updated by calling the `addfile`, `removefile` and
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1439 `dropfile` methods.
35078 a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1440
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1441 - `copymap` maps destination filenames to their source filename.
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1442
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1443 The dirstate also provides the following views onto the state:
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1444
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1445 - `nonnormalset` is a set of the filenames that have state other
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1446 than 'normal', or are normal but have an mtime of -1 ('normallookup').
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1447
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1448 - `otherparentset` is a set of the filenames that are marked as coming
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1449 from the second parent when the dirstate is currently being merged.
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1450
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1451 - `filefoldmap` is a dict mapping normalized filenames to the denormalized
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1452 form that they appear as in the dirstate.
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1453
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1454 - `dirfoldmap` is a dict mapping normalized directory names to the
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1455 denormalized form that they appear as in the dirstate.
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1456 """
a052022639cc dirstate: document dirstatemap interface Mark Thomas <mbthomas@fb.com> parents: 35016 diff changeset	1457
47280 1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1458 def __init__(self, ui, opener, root, nodeconstants, use_dirstate_v2):
34337 c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1459 self._ui = ui
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1460 self._opener = opener
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1461 self._root = root
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1462 self._filename = b'dirstate'
45219 4f0e03d980f3 dirstate: isolate node len dependency for the pure version Joerg Sonnenberger <joerg@bec.de> parents: 44852 diff changeset	1463 self._nodelen = 20
46780 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 45942 diff changeset	1464 self._nodeconstants = nodeconstants
47280 1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1465 assert (
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1466 not use_dirstate_v2
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1467 ), "should have detected unsupported requirement"
34337 c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1468
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1469 self._parents = None
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1470 self._dirtyparents = False
34332 b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1471
34337 c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1472 # for consistent view between _pl() and _read() invocations
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1473 self._pendingmode = None
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1474
34934 6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1475 @propertycache
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1476 def _map(self):
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1477 self._map = {}
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1478 self.read()
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1479 return self._map
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1480
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1481 @propertycache
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1482 def copymap(self):
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1483 self.copymap = {}
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1484 self._map
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1485 return self.copymap
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1486
47351 3b9914b28133 dirstate-v2: Add --dirs to debugdirstate command Simon Sapin <simon.sapin@octobus.net> parents: 47350 diff changeset	1487 def directories(self):
3b9914b28133 dirstate-v2: Add --dirs to debugdirstate command Simon Sapin <simon.sapin@octobus.net> parents: 47350 diff changeset	1488 # Rust / dirstate-v2 only
3b9914b28133 dirstate-v2: Add --dirs to debugdirstate command Simon Sapin <simon.sapin@octobus.net> parents: 47350 diff changeset	1489 return []
3b9914b28133 dirstate-v2: Add --dirs to debugdirstate command Simon Sapin <simon.sapin@octobus.net> parents: 47350 diff changeset	1490
34933 0217f75b6e59 dirstate: move clear onto dirstatemap class Durham Goode <durham@fb.com> parents: 34678 diff changeset	1491 def clear(self):
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1492 self._map.clear()
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1493 self.copymap.clear()
47012 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	1494 self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1495 util.clearcachedproperty(self, b"_dirs")
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1496 util.clearcachedproperty(self, b"_alldirs")
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1497 util.clearcachedproperty(self, b"filefoldmap")
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1498 util.clearcachedproperty(self, b"dirfoldmap")
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1499 util.clearcachedproperty(self, b"nonnormalset")
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1500 util.clearcachedproperty(self, b"otherparentset")
34933 0217f75b6e59 dirstate: move clear onto dirstatemap class Durham Goode <durham@fb.com> parents: 34678 diff changeset	1501
35878 6e7fae8f1c6c contrib: fix dirstatenonnormalcheck to work in Python 3 Augie Fackler <augie@google.com> parents: 35835 diff changeset	1502 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	1503 return pycompat.iteritems(self._map)
34332 b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1504
35878 6e7fae8f1c6c contrib: fix dirstatenonnormalcheck to work in Python 3 Augie Fackler <augie@google.com> parents: 35835 diff changeset	1505 # forward for python2,3 compat
6e7fae8f1c6c contrib: fix dirstatenonnormalcheck to work in Python 3 Augie Fackler <augie@google.com> parents: 35835 diff changeset	1506 iteritems = items
6e7fae8f1c6c contrib: fix dirstatenonnormalcheck to work in Python 3 Augie Fackler <augie@google.com> parents: 35835 diff changeset	1507
34408 7d2f71b7bc31 dirstate: implement __len__ on dirstatemap (issue5695) Simon Whitaker <swhitaker@fb.com> parents: 34339 diff changeset	1508 def __len__(self):
7d2f71b7bc31 dirstate: implement __len__ on dirstatemap (issue5695) Simon Whitaker <swhitaker@fb.com> parents: 34339 diff changeset	1509 return len(self._map)
7d2f71b7bc31 dirstate: implement __len__ on dirstatemap (issue5695) Simon Whitaker <swhitaker@fb.com> parents: 34339 diff changeset	1510
34332 b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1511 def __iter__(self):
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1512 return iter(self._map)
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1513
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1514 def get(self, key, default=None):
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1515 return self._map.get(key, default)
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1516
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1517 def __contains__(self, key):
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1518 return key in self._map
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1519
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1520 def __getitem__(self, key):
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1521 return self._map[key]
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1522
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1523 def keys(self):
b36881c68569 dirstate: create new dirstatemap class Durham Goode <durham@fb.com> parents: 34188 diff changeset	1524 return self._map.keys()
34333 4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1525
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1526 def preload(self):
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1527 """Loads the underlying data, if it's not already loaded"""
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1528 self._map
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1529
35081 a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap Mark Thomas <mbthomas@fb.com> parents: 35080 diff changeset	1530 def addfile(self, f, oldstate, state, mode, size, mtime):
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1531 """Add a tracked file to the dirstate."""
43503 313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings Augie Fackler <augie@google.com> parents: 43456 diff changeset	1532 if oldstate in b"?r" and "_dirs" in self.__dict__:
35084 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1533 self._dirs.addpath(f)
43503 313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings Augie Fackler <augie@google.com> parents: 43456 diff changeset	1534 if oldstate == b"?" and "_alldirs" in self.__dict__:
35084 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1535 self._alldirs.addpath(f)
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1536 self._map[f] = dirstatetuple(state, mode, size, mtime)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1537 if state != b'n' or mtime == -1:
35080 19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1538 self.nonnormalset.add(f)
47482 cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47481 diff changeset	1539 if size == FROM_P2:
35080 19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1540 self.otherparentset.add(f)
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1541
35081 a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap Mark Thomas <mbthomas@fb.com> parents: 35080 diff changeset	1542 def removefile(self, f, oldstate, size):
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1543 """
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1544 Mark a file as removed in the dirstate.
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1545
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1546 The `size` parameter is used to store sentinel values that indicate
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1547 the file's previous state. In the future, we should refactor this
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1548 to be more explicit about what that state is.
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1549 """
43503 313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings Augie Fackler <augie@google.com> parents: 43456 diff changeset	1550 if oldstate not in b"?r" and "_dirs" in self.__dict__:
35084 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1551 self._dirs.delpath(f)
43503 313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings Augie Fackler <augie@google.com> parents: 43456 diff changeset	1552 if oldstate == b"?" and "_alldirs" in self.__dict__:
35084 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1553 self._alldirs.addpath(f)
43503 313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings Augie Fackler <augie@google.com> parents: 43456 diff changeset	1554 if "filefoldmap" in self.__dict__:
35082 e6c64744781f dirstate: move dropping of folded filenames into the dirstate map Mark Thomas <mbthomas@fb.com> parents: 35081 diff changeset	1555 normed = util.normcase(f)
e6c64744781f dirstate: move dropping of folded filenames into the dirstate map Mark Thomas <mbthomas@fb.com> parents: 35081 diff changeset	1556 self.filefoldmap.pop(normed, None)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1557 self._map[f] = dirstatetuple(b'r', 0, size, 0)
35080 19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1558 self.nonnormalset.add(f)
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1559
35081 a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap Mark Thomas <mbthomas@fb.com> parents: 35080 diff changeset	1560 def dropfile(self, f, oldstate):
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1561 """
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1562 Remove a file from the dirstate. Returns True if the file was
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1563 previously recorded.
853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1564 """
35080 19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1565 exists = self._map.pop(f, None) is not None
35081 a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap Mark Thomas <mbthomas@fb.com> parents: 35080 diff changeset	1566 if exists:
43503 313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings Augie Fackler <augie@google.com> parents: 43456 diff changeset	1567 if oldstate != b"r" and "_dirs" in self.__dict__:
35084 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1568 self._dirs.delpath(f)
43503 313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings Augie Fackler <augie@google.com> parents: 43456 diff changeset	1569 if "_alldirs" in self.__dict__:
35084 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1570 self._alldirs.delpath(f)
43503 313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings Augie Fackler <augie@google.com> parents: 43456 diff changeset	1571 if "filefoldmap" in self.__dict__:
35082 e6c64744781f dirstate: move dropping of folded filenames into the dirstate map Mark Thomas <mbthomas@fb.com> parents: 35081 diff changeset	1572 normed = util.normcase(f)
e6c64744781f dirstate: move dropping of folded filenames into the dirstate map Mark Thomas <mbthomas@fb.com> parents: 35081 diff changeset	1573 self.filefoldmap.pop(normed, None)
35080 19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1574 self.nonnormalset.discard(f)
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1575 return exists
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1576
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1577 def clearambiguoustimes(self, files, now):
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1578 for f in files:
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1579 e = self.get(f)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1580 if e is not None and e[0] == b'n' and e[3] == now:
35080 19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1581 self._map[f] = dirstatetuple(e[0], e[1], e[2], -1)
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map Mark Thomas <mbthomas@fb.com> parents: 35079 diff changeset	1582 self.nonnormalset.add(f)
35079 853b7c41d19c dirstate: add explicit methods for modifying dirstate Mark Thomas <mbthomas@fb.com> parents: 35078 diff changeset	1583
34333 4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1584 def nonnormalentries(self):
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1585 '''Compute the nonnormal dirstate entries from the dmap'''
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1586 try:
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1587 return parsers.nonnormalotherparententries(self._map)
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1588 except AttributeError:
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1589 nonnorm = set()
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1590 otherparent = set()
43106 d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43090 diff changeset	1591 for fname, e in pycompat.iteritems(self._map):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1592 if e[0] != b'n' or e[3] == -1:
34333 4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1593 nonnorm.add(fname)
47482 cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47481 diff changeset	1594 if e[0] == b'n' and e[2] == FROM_P2:
34333 4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1595 otherparent.add(fname)
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1596 return nonnorm, otherparent
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap Durham Goode <durham@fb.com> parents: 34332 diff changeset	1597
34676 bfddc3d678ae dirstate: remove _filefoldmap property cache Durham Goode <durham@fb.com> parents: 34675 diff changeset	1598 @propertycache
34334 d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1599 def filefoldmap(self):
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1600 """Returns a dictionary mapping normalized case paths to their
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1601 non-normalized versions.
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1602 """
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1603 try:
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1604 makefilefoldmap = parsers.make_file_foldmap
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1605 except AttributeError:
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1606 pass
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1607 else:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1608 return makefilefoldmap(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1609 self._map, util.normcasespec, util.normcasefallback
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1610 )
34334 d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1611
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1612 f = {}
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1613 normcase = util.normcase
43106 d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43090 diff changeset	1614 for name, s in pycompat.iteritems(self._map):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1615 if s[0] != b'r':
34334 d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1616 f[normcase(name)] = name
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1617 f[b'.'] = b'.' # prevents useless util.fspath() invocation
34334 d8b35920b7b1 dirstate: move filefoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34333 diff changeset	1618 return f
34335 af9722412ac3 dirstate: move _dirs to dirstatemap Durham Goode <durham@fb.com> parents: 34334 diff changeset	1619
35084 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1620 def hastrackeddir(self, d):
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1621 """
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1622 Returns True if the dirstate contains a tracked (not removed) file
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1623 in this directory.
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1624 """
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1625 return d in self._dirs
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1626
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1627 def hasdir(self, d):
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1628 """
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1629 Returns True if the dirstate contains a file (tracked or removed)
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1630 in this directory.
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1631 """
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1632 return d in self._alldirs
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1633
34677 014bd2a555c8 dirstate: remove _dirs property cache Durham Goode <durham@fb.com> parents: 34676 diff changeset	1634 @propertycache
35084 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1635 def _dirs(self):
43523 c21aca51b392 utils: move the `dirs` definition in pathutil (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43506 diff changeset	1636 return pathutil.dirs(self._map, b'r')
34337 c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1637
35084 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1638 @propertycache
61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1639 def _alldirs(self):
43523 c21aca51b392 utils: move the `dirs` definition in pathutil (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43506 diff changeset	1640 return pathutil.dirs(self._map)
35084 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1641
34337 c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1642 def _opendirstatefile(self):
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1643 fp, mode = txnutil.trypending(self._root, self._opener, self._filename)
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1644 if self._pendingmode is not None and self._pendingmode != mode:
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1645 fp.close()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1646 raise error.Abort(
43117 8ff1ecfadcd1 cleanup: join string literals that are already on one line Martin von Zweigbergk <martinvonz@google.com> parents: 43106 diff changeset	1647 _(b'working directory state may be changed parallelly')
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1648 )
34337 c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1649 self._pendingmode = mode
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1650 return fp
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap Durham Goode <durham@fb.com> parents: 34336 diff changeset	1651
34338 0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class Durham Goode <durham@fb.com> parents: 34337 diff changeset	1652 def parents(self):
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1653 if not self._parents:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1654 try:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1655 fp = self._opendirstatefile()
45219 4f0e03d980f3 dirstate: isolate node len dependency for the pure version Joerg Sonnenberger <joerg@bec.de> parents: 44852 diff changeset	1656 st = fp.read(2 * self._nodelen)
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1657 fp.close()
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1658 except IOError as err:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1659 if err.errno != errno.ENOENT:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1660 raise
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1661 # File doesn't exist, so the current state is empty
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1662 st = b''
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1663
34338 0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class Durham Goode <durham@fb.com> parents: 34337 diff changeset	1664 l = len(st)
45219 4f0e03d980f3 dirstate: isolate node len dependency for the pure version Joerg Sonnenberger <joerg@bec.de> parents: 44852 diff changeset	1665 if l == self._nodelen * 2:
4f0e03d980f3 dirstate: isolate node len dependency for the pure version Joerg Sonnenberger <joerg@bec.de> parents: 44852 diff changeset	1666 self._parents = (
4f0e03d980f3 dirstate: isolate node len dependency for the pure version Joerg Sonnenberger <joerg@bec.de> parents: 44852 diff changeset	1667 st[: self._nodelen],
4f0e03d980f3 dirstate: isolate node len dependency for the pure version Joerg Sonnenberger <joerg@bec.de> parents: 44852 diff changeset	1668 st[self._nodelen : 2 * self._nodelen],
4f0e03d980f3 dirstate: isolate node len dependency for the pure version Joerg Sonnenberger <joerg@bec.de> parents: 44852 diff changeset	1669 )
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1670 elif l == 0:
47012 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	1671 self._parents = (
d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	1672 self._nodeconstants.nullid,
d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	1673 self._nodeconstants.nullid,
d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	1674 )
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1675 else:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1676 raise error.Abort(
43117 8ff1ecfadcd1 cleanup: join string literals that are already on one line Martin von Zweigbergk <martinvonz@google.com> parents: 43106 diff changeset	1677 _(b'working directory state appears damaged!')
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1678 )
34339 ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1679
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1680 return self._parents
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1681
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1682 def setparents(self, p1, p2):
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1683 self._parents = (p1, p2)
ec769bba34d3 dirstate: move parents source of truth to dirstatemap Durham Goode <durham@fb.com> parents: 34338 diff changeset	1684 self._dirtyparents = True
34672 e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1685
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1686 def read(self):
34675 c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	1687 # ignore HG_PENDING because identity is used only for writing
c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	1688 self.identity = util.filestat.frompath(
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1689 self._opener.join(self._filename)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1690 )
34675 c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	1691
34672 e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1692 try:
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1693 fp = self._opendirstatefile()
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1694 try:
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1695 st = fp.read()
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1696 finally:
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1697 fp.close()
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1698 except IOError as err:
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1699 if err.errno != errno.ENOENT:
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1700 raise
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1701 return
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1702 if not st:
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1703 return
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1704
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1705 if util.safehasattr(parsers, b'dict_new_presized'):
34672 e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1706 # Make an estimate of the number of files in the dirstate based on
45243 ad7006830106 dirstate: restore original estimation and update comment Joerg Sonnenberger <joerg@bec.de> parents: 45241 diff changeset	1707 # its size. This trades wasting some memory for avoiding costly
ad7006830106 dirstate: restore original estimation and update comment Joerg Sonnenberger <joerg@bec.de> parents: 45241 diff changeset	1708 # resizes. Each entry have a prefix of 17 bytes followed by one or
ad7006830106 dirstate: restore original estimation and update comment Joerg Sonnenberger <joerg@bec.de> parents: 45241 diff changeset	1709 # two path names. Studies on various large-scale real-world repositories
ad7006830106 dirstate: restore original estimation and update comment Joerg Sonnenberger <joerg@bec.de> parents: 45241 diff changeset	1710 # found 54 bytes a reasonable upper limit for the average path names.
ad7006830106 dirstate: restore original estimation and update comment Joerg Sonnenberger <joerg@bec.de> parents: 45241 diff changeset	1711 # Copy entries are ignored for the sake of this estimate.
ad7006830106 dirstate: restore original estimation and update comment Joerg Sonnenberger <joerg@bec.de> parents: 45241 diff changeset	1712 self._map = parsers.dict_new_presized(len(st) // 71)
34672 e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1713
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1714 # Python's garbage collector triggers a GC each time a certain number
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1715 # of container objects (the number being defined by
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1716 # gc.get_threshold()) are allocated. parse_dirstate creates a tuple
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1717 # for each file in the dirstate. The C version then immediately marks
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1718 # them as not to be tracked by the collector. However, this has no
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1719 # effect on when GCs are triggered, only on what objects the GC looks
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1720 # into. This means that O(number of files) GCs are unavoidable.
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1721 # Depending on when in the process's lifetime the dirstate is parsed,
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1722 # this can get very expensive. As a workaround, disable GC while
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1723 # parsing the dirstate.
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1724 #
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1725 # (we cannot decorate the function directly since it is in a C module)
42747 760a7851e9ba rust-parsers: move parser bindings to their own file and Python module Rapha?l Gom?s <rgomes@octobus.net> parents: 42456 diff changeset	1726 parse_dirstate = util.nogc(parsers.parse_dirstate)
34672 e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1727 p = parse_dirstate(self._map, self.copymap, st)
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1728 if not self._dirtyparents:
e159f217230e dirstate: move _read into dirstatemap Durham Goode <durham@fb.com> parents: 34480 diff changeset	1729 self.setparents(*p)
34673 e2214632c3a2 dirstate: move write into dirstatemap Durham Goode <durham@fb.com> parents: 34672 diff changeset	1730
34935 ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1731 # Avoid excess attribute lookups by fast pathing certain checks
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1732 self.__contains__ = self._map.__contains__
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1733 self.__getitem__ = self._map.__getitem__
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1734 self.get = self._map.get
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714) Durham Goode <durham@fb.com> parents: 34934 diff changeset	1735
34673 e2214632c3a2 dirstate: move write into dirstatemap Durham Goode <durham@fb.com> parents: 34672 diff changeset	1736 def write(self, st, now):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1737 st.write(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1738 parsers.pack_dirstate(self._map, self.copymap, self.parents(), now)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1739 )
34673 e2214632c3a2 dirstate: move write into dirstatemap Durham Goode <durham@fb.com> parents: 34672 diff changeset	1740 st.close()
e2214632c3a2 dirstate: move write into dirstatemap Durham Goode <durham@fb.com> parents: 34672 diff changeset	1741 self._dirtyparents = False
34674 60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1742 self.nonnormalset, self.otherparentset = self.nonnormalentries()
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1743
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1744 @propertycache
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1745 def nonnormalset(self):
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1746 nonnorm, otherparents = self.nonnormalentries()
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1747 self.otherparentset = otherparents
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1748 return nonnorm
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1749
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1750 @propertycache
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1751 def otherparentset(self):
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1752 nonnorm, otherparents = self.nonnormalentries()
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1753 self.nonnormalset = nonnorm
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1754 return otherparents
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap Durham Goode <durham@fb.com> parents: 34673 diff changeset	1755
47094 e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets Simon Sapin <simon.sapin@octobus.net> parents: 47012 diff changeset	1756 def non_normal_or_other_parent_paths(self):
e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets Simon Sapin <simon.sapin@octobus.net> parents: 47012 diff changeset	1757 return self.nonnormalset.union(self.otherparentset)
e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets Simon Sapin <simon.sapin@octobus.net> parents: 47012 diff changeset	1758
34675 c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	1759 @propertycache
c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	1760 def identity(self):
34934 6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717) Durham Goode <durham@fb.com> parents: 34933 diff changeset	1761 self._map
34675 c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	1762 return self.identity
c6ef9a2498a5 dirstate: move identity to dirstatemap Durham Goode <durham@fb.com> parents: 34674 diff changeset	1763
34678 e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	1764 @propertycache
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	1765 def dirfoldmap(self):
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	1766 f = {}
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	1767 normcase = util.normcase
35084 61888bd0b300 dirstate: add explicit methods for querying directories (API) Mark Thomas <mbthomas@fb.com> parents: 35083 diff changeset	1768 for name in self._dirs:
34678 e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	1769 f[normcase(name)] = name
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap Durham Goode <durham@fb.com> parents: 34677 diff changeset	1770 return f
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1771
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1772
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1773 if rustmod is not None:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1774
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1775 class dirstatemap(object):
47280 1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1776 def __init__(self, ui, opener, root, nodeconstants, use_dirstate_v2):
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1777 self._use_dirstate_v2 = use_dirstate_v2
46780 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 45942 diff changeset	1778 self._nodeconstants = nodeconstants
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1779 self._ui = ui
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1780 self._opener = opener
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1781 self._root = root
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1782 self._filename = b'dirstate'
47280 1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1783 self._nodelen = 20 # Also update Rust code when changing this!
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1784 self._parents = None
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1785 self._dirtyparents = False
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1786
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1787 # for consistent view between _pl() and _read() invocations
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1788 self._pendingmode = None
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1789
47320 a43d256c041a dirstate-v2: Add `hg debugupgraderepo` command support Simon Sapin <simon.sapin@octobus.net> parents: 47280 diff changeset	1790 self._use_dirstate_tree = self._ui.configbool(
a43d256c041a dirstate-v2: Add `hg debugupgraderepo` command support Simon Sapin <simon.sapin@octobus.net> parents: 47280 diff changeset	1791 b"experimental",
a43d256c041a dirstate-v2: Add `hg debugupgraderepo` command support Simon Sapin <simon.sapin@octobus.net> parents: 47280 diff changeset	1792 b"dirstate-tree.in-memory",
a43d256c041a dirstate-v2: Add `hg debugupgraderepo` command support Simon Sapin <simon.sapin@octobus.net> parents: 47280 diff changeset	1793 False,
a43d256c041a dirstate-v2: Add `hg debugupgraderepo` command support Simon Sapin <simon.sapin@octobus.net> parents: 47280 diff changeset	1794 )
a43d256c041a dirstate-v2: Add `hg debugupgraderepo` command support Simon Sapin <simon.sapin@octobus.net> parents: 47280 diff changeset	1795
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1796 def addfile(self, args, *kwargs):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1797 return self._rustmap.addfile(args, *kwargs)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1798
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1799 def removefile(self, args, *kwargs):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1800 return self._rustmap.removefile(args, *kwargs)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1801
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1802 def dropfile(self, args, *kwargs):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1803 return self._rustmap.dropfile(args, *kwargs)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1804
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1805 def clearambiguoustimes(self, args, *kwargs):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1806 return self._rustmap.clearambiguoustimes(args, *kwargs)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1807
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1808 def nonnormalentries(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1809 return self._rustmap.nonnormalentries()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1810
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1811 def get(self, args, *kwargs):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1812 return self._rustmap.get(args, *kwargs)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1813
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1814 @property
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1815 def copymap(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1816 return self._rustmap.copymap()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1817
47351 3b9914b28133 dirstate-v2: Add --dirs to debugdirstate command Simon Sapin <simon.sapin@octobus.net> parents: 47350 diff changeset	1818 def directories(self):
3b9914b28133 dirstate-v2: Add --dirs to debugdirstate command Simon Sapin <simon.sapin@octobus.net> parents: 47350 diff changeset	1819 return self._rustmap.directories()
3b9914b28133 dirstate-v2: Add --dirs to debugdirstate command Simon Sapin <simon.sapin@octobus.net> parents: 47350 diff changeset	1820
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1821 def preload(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1822 self._rustmap
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1823
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1824 def clear(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1825 self._rustmap.clear()
47012 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	1826 self.setparents(
d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	1827 self._nodeconstants.nullid, self._nodeconstants.nullid
d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	1828 )
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1829 util.clearcachedproperty(self, b"_dirs")
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1830 util.clearcachedproperty(self, b"_alldirs")
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1831 util.clearcachedproperty(self, b"dirfoldmap")
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1832
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1833 def items(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1834 return self._rustmap.items()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1835
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1836 def keys(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1837 return iter(self._rustmap)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1838
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1839 def __contains__(self, key):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1840 return key in self._rustmap
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1841
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1842 def __getitem__(self, item):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1843 return self._rustmap[item]
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1844
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1845 def __len__(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1846 return len(self._rustmap)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1847
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1848 def __iter__(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1849 return iter(self._rustmap)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1850
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1851 # forward for python2,3 compat
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1852 iteritems = items
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1853
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1854 def _opendirstatefile(self):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1855 fp, mode = txnutil.trypending(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1856 self._root, self._opener, self._filename
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1857 )
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1858 if self._pendingmode is not None and self._pendingmode != mode:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1859 fp.close()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1860 raise error.Abort(
43117 8ff1ecfadcd1 cleanup: join string literals that are already on one line Martin von Zweigbergk <martinvonz@google.com> parents: 43106 diff changeset	1861 _(b'working directory state may be changed parallelly')
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1862 )
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1863 self._pendingmode = mode
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1864 return fp
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1865
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1866 def setparents(self, p1, p2):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1867 self._parents = (p1, p2)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1868 self._dirtyparents = True
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1869
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1870 def parents(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1871 if not self._parents:
47280 1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1872 if self._use_dirstate_v2:
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1873 offset = len(rustmod.V2_FORMAT_MARKER)
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1874 else:
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1875 offset = 0
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1876 read_len = offset + self._nodelen * 2
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1877 try:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1878 fp = self._opendirstatefile()
47280 1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1879 st = fp.read(read_len)
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1880 fp.close()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1881 except IOError as err:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1882 if err.errno != errno.ENOENT:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1883 raise
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1884 # File doesn't exist, so the current state is empty
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1885 st = b''
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1886
47121 b6339a993b91 rust: Remove handling of `parents` in `DirstateMap` Simon Sapin <simon.sapin@octobus.net> parents: 47095 diff changeset	1887 l = len(st)
47280 1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1888 if l == read_len:
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1889 st = st[offset:]
47121 b6339a993b91 rust: Remove handling of `parents` in `DirstateMap` Simon Sapin <simon.sapin@octobus.net> parents: 47095 diff changeset	1890 self._parents = (
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap` Simon Sapin <simon.sapin@octobus.net> parents: 47095 diff changeset	1891 st[: self._nodelen],
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap` Simon Sapin <simon.sapin@octobus.net> parents: 47095 diff changeset	1892 st[self._nodelen : 2 * self._nodelen],
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap` Simon Sapin <simon.sapin@octobus.net> parents: 47095 diff changeset	1893 )
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap` Simon Sapin <simon.sapin@octobus.net> parents: 47095 diff changeset	1894 elif l == 0:
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap` Simon Sapin <simon.sapin@octobus.net> parents: 47095 diff changeset	1895 self._parents = (
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap` Simon Sapin <simon.sapin@octobus.net> parents: 47095 diff changeset	1896 self._nodeconstants.nullid,
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap` Simon Sapin <simon.sapin@octobus.net> parents: 47095 diff changeset	1897 self._nodeconstants.nullid,
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap` Simon Sapin <simon.sapin@octobus.net> parents: 47095 diff changeset	1898 )
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap` Simon Sapin <simon.sapin@octobus.net> parents: 47095 diff changeset	1899 else:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1900 raise error.Abort(
43117 8ff1ecfadcd1 cleanup: join string literals that are already on one line Martin von Zweigbergk <martinvonz@google.com> parents: 43106 diff changeset	1901 _(b'working directory state appears damaged!')
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1902 )
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1903
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1904 return self._parents
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1905
47122 9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor Simon Sapin <simon.sapin@octobus.net> parents: 47121 diff changeset	1906 @propertycache
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor Simon Sapin <simon.sapin@octobus.net> parents: 47121 diff changeset	1907 def _rustmap(self):
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor Simon Sapin <simon.sapin@octobus.net> parents: 47121 diff changeset	1908 """
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor Simon Sapin <simon.sapin@octobus.net> parents: 47121 diff changeset	1909 Fills the Dirstatemap when called.
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor Simon Sapin <simon.sapin@octobus.net> parents: 47121 diff changeset	1910 """
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1911 # ignore HG_PENDING because identity is used only for writing
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1912 self.identity = util.filestat.frompath(
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1913 self._opener.join(self._filename)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42927 diff changeset	1914 )
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1915
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1916 try:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1917 fp = self._opendirstatefile()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1918 try:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1919 st = fp.read()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1920 finally:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1921 fp.close()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1922 except IOError as err:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1923 if err.errno != errno.ENOENT:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1924 raise
47122 9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor Simon Sapin <simon.sapin@octobus.net> parents: 47121 diff changeset	1925 st = b''
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1926
47122 9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor Simon Sapin <simon.sapin@octobus.net> parents: 47121 diff changeset	1927 self._rustmap, parents = rustmod.DirstateMap.new(
47320 a43d256c041a dirstate-v2: Add `hg debugupgraderepo` command support Simon Sapin <simon.sapin@octobus.net> parents: 47280 diff changeset	1928 self._use_dirstate_tree, self._use_dirstate_v2, st
47122 9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor Simon Sapin <simon.sapin@octobus.net> parents: 47121 diff changeset	1929 )
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor Simon Sapin <simon.sapin@octobus.net> parents: 47121 diff changeset	1930
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1931 if parents and not self._dirtyparents:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1932 self.setparents(*parents)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1933
43280 5d4046594d6f rust-dirstatemap: remove additional lookups in dirstatemap Rapha?l Gom?s <rgomes@octobus.net> parents: 43274 diff changeset	1934 self.__contains__ = self._rustmap.__contains__
5d4046594d6f rust-dirstatemap: remove additional lookups in dirstatemap Rapha?l Gom?s <rgomes@octobus.net> parents: 43274 diff changeset	1935 self.__getitem__ = self._rustmap.__getitem__
5d4046594d6f rust-dirstatemap: remove additional lookups in dirstatemap Rapha?l Gom?s <rgomes@octobus.net> parents: 43274 diff changeset	1936 self.get = self._rustmap.get
47122 9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor Simon Sapin <simon.sapin@octobus.net> parents: 47121 diff changeset	1937 return self._rustmap
43280 5d4046594d6f rust-dirstatemap: remove additional lookups in dirstatemap Rapha?l Gom?s <rgomes@octobus.net> parents: 43274 diff changeset	1938
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1939 def write(self, st, now):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1940 parents = self.parents()
47280 1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1941 packed = self._rustmap.write(
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1942 self._use_dirstate_v2, parents[0], parents[1], now
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1943 )
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled Simon Sapin <simon.sapin@octobus.net> parents: 47277 diff changeset	1944 st.write(packed)
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1945 st.close()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1946 self._dirtyparents = False
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1947
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1948 @propertycache
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1949 def filefoldmap(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1950 """Returns a dictionary mapping normalized case paths to their
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1951 non-normalized versions.
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1952 """
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1953 return self._rustmap.filefoldmapasdict()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1954
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1955 def hastrackeddir(self, d):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1956 return self._rustmap.hastrackeddir(d)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1957
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1958 def hasdir(self, d):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1959 return self._rustmap.hasdir(d)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1960
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1961 @propertycache
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1962 def identity(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1963 self._rustmap
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1964 return self.identity
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1965
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1966 @property
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1967 def nonnormalset(self):
44297 cf1f8660e568 rust-dirstatemap: add `NonNormalEntries` class Rapha?l Gom?s <rgomes@octobus.net> parents: 44227 diff changeset	1968 nonnorm = self._rustmap.non_normal_entries()
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1969 return nonnorm
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1970
44227 7f5410dfc8a6 rust-dirstatemap: add missing @propertycache Rapha?l Gom?s <rgomes@octobus.net> parents: 44078 diff changeset	1971 @propertycache
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1972 def otherparentset(self):
44297 cf1f8660e568 rust-dirstatemap: add `NonNormalEntries` class Rapha?l Gom?s <rgomes@octobus.net> parents: 44227 diff changeset	1973 otherparents = self._rustmap.other_parent_entries()
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1974 return otherparents
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1975
47094 e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets Simon Sapin <simon.sapin@octobus.net> parents: 47012 diff changeset	1976 def non_normal_or_other_parent_paths(self):
e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets Simon Sapin <simon.sapin@octobus.net> parents: 47012 diff changeset	1977 return self._rustmap.non_normal_or_other_parent_paths()
e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets Simon Sapin <simon.sapin@octobus.net> parents: 47012 diff changeset	1978
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1979 @propertycache
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1980 def dirfoldmap(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1981 f = {}
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1982 normcase = util.normcase
47477 eb416759af7e dirstate: Removed unused instances of `DirsMultiset` Simon Sapin <simon.sapin@octobus.net> parents: 47351 diff changeset	1983 for name, _pseudo_entry in self.directories():
42755 749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1984 f[normcase(name)] = name
749ef8c31187 rust-dirstate: call rust dirstatemap from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42747 diff changeset	1985 return f

Mercurial > public > mercurial-scm > hg

annotate mercurial/dirstate.py @ 47482:cb29484eaade