Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/dirstate.py @ 48013:87b3010c08e0

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