Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/dirstate.py @ 47921:3853e6ee160d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
dirstatemap: replace `removefile` by an explicit `entry.set_untracked()` All the other caller goes through `reset_state`, so we can safely have an explicit method on `DirstateItem` object. This means that all the logic to preserve the previous state (from p2, merged, etc) is now properly encapsulated within the DirstateItem. This pave the way to using different storage for these information. Differential Revision: https://phab.mercurial-scm.org/D11315
author Pierre-Yves David <pierre-yves.david@octobus.net>
date Fri, 20 Aug 2021 11:27:01 +0200
parents 6614ab9f061d
children f89ac1ed2bc6
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 = {}
47055
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
390 if (
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
391 oldp2 != self._nodeconstants.nullid
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
392 and p2 == self._nodeconstants.nullid
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
393 ):
47108
e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets
Simon Sapin <simon.sapin@octobus.net>
parents: 47055
diff changeset
394 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
395
31287
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31218
diff changeset
396 for f in candidatefiles:
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31218
diff changeset
397 s = self._map.get(f)
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31218
diff changeset
398 if s is None:
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31218
diff changeset
399 continue
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31218
diff changeset
400
47513
10e740292dff dirstate-entry: add a `merged` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47512
diff changeset
401 # 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
402 if s.merged:
34343
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34342
diff changeset
403 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
404 if source:
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 33763
diff changeset
405 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
406 self._normallookup(f)
22895
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
407 # 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
408 elif s.from_p2:
34343
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34342
diff changeset
409 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
410 if source:
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 33763
diff changeset
411 copies[f] = source
47589
f5c24c124e07 dirstate: introduce an internal `_add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47558
diff changeset
412 self._add(f)
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
413 return copies
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
414
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
415 def setbranch(self, branch):
40493
7caf632e30c3 filecache: unimplement __set__() and __delete__() (API)
Yuya Nishihara <yuya@tcha.org>
parents: 39823
diff changeset
416 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
417 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
418 try:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
419 f.write(self._branch + b'\n')
16472
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
420 f.close()
18317
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
421
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
422 # 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
423 # replacing the underlying file
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
424 ce = self._filecache[b'_branch']
18317
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
425 if ce:
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
426 ce.refresh()
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
427 except: # re-raises
18076
3bc21f6daac4 dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents: 17984
diff changeset
428 f.discard()
3bc21f6daac4 dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents: 17984
diff changeset
429 raise
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
430
4613
3a645af7fb76 localrepo and dirstate: rename reload to invalidate
Matt Mackall <mpm@selenic.com>
parents: 4612
diff changeset
431 def invalidate(self):
45957
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45269
diff changeset
432 """Causes the next access to reread the dirstate.
32702
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32631
diff changeset
433
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32631
diff changeset
434 This is different from localrepo.invalidatedirstate() because it always
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32631
diff changeset
435 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
436 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
437
43551
313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings
Augie Fackler <augie@google.com>
parents: 43508
diff changeset
438 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
439 if a in self.__dict__:
6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4952
diff changeset
440 delattr(self, a)
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
441 self._lastnormaltime = 0
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
442 self._dirty = False
31216
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31070
diff changeset
443 self._updatedfiles.clear()
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
444 self._parentwriters = 0
29783
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29687
diff changeset
445 self._origpl = None
4375
109077e7048d When reloading the dirstate, recompute ignore information if needed.
Bryan O'Sullivan <bos@serpentine.com>
parents: 4374
diff changeset
446
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
447 def copy(self, source, dest):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
448 """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
449 if source == dest:
deda205a00e1 Ignore dummy copies in dirstate and localrepo.filecommit()
Patrick Mezard <pmezard@gmail.com>
parents: 6479
diff changeset
450 return
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
451 self._dirty = True
7566
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents: 7280
diff changeset
452 if source is not None:
34343
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34342
diff changeset
453 self._map.copymap[dest] = source
31216
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31070
diff changeset
454 self._updatedfiles.add(source)
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31070
diff changeset
455 self._updatedfiles.add(dest)
34343
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34342
diff changeset
456 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
457 self._updatedfiles.add(dest)
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
458
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
459 def copied(self, file):
34343
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34342
diff changeset
460 return self._map.copymap.get(file, None)
3154
b1f10d3223c1 dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents: 2962
diff changeset
461
b1f10d3223c1 dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents: 2962
diff changeset
462 def copies(self):
34343
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34342
diff changeset
463 return self._map.copymap
515
03f27b1381f9 Whitespace cleanups
mpm@selenic.com
parents: 514
diff changeset
464
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
465 @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
466 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
467 """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
468
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 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
470 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
471
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 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
473 """
f927ad5a4e2c dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47592
diff changeset
474 entry = self._map.get(filename)
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 if entry is None:
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 self._add(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
477 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
478 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
479 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
480 return True
47731
485ae37a7ec5 dirstate: enforce `possibly_dirty` in `set_tracked`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47720
diff changeset
481 # 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
482 # 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
483 # 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
484 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
485 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
486
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
487 @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
488 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
489 """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
490
cce51119bfe6 dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47594
diff changeset
491 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
492 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
493
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 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
495 """
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 entry = self._map.get(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
497 if entry is None:
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 return False
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 elif entry.added:
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 self._drop(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
501 return True
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 else:
47912
1c797757f5bb dirstate: directly call the dirstatemap in `set_untracked`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47777
diff changeset
503 self._dirty = True
1c797757f5bb dirstate: directly call the dirstatemap in `set_untracked`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47777
diff changeset
504 self._updatedfiles.add(filename)
47921
3853e6ee160d dirstatemap: replace `removefile` by an explicit `entry.set_untracked()`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47920
diff changeset
505 self._map.set_untracked(filename)
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
506 return True
cce51119bfe6 dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47594
diff changeset
507
47704
8a50fb0784a9 dirstate: introduce a `set_clean` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47701
diff changeset
508 @requires_no_parents_change
8a50fb0784a9 dirstate: introduce a `set_clean` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47701
diff changeset
509 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
510 """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
511 self._dirty = True
8a50fb0784a9 dirstate: introduce a `set_clean` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47701
diff changeset
512 self._updatedfiles.add(filename)
47719
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
513 self._normal(filename, parentfiledata=parentfiledata)
47704
8a50fb0784a9 dirstate: introduce a `set_clean` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47701
diff changeset
514
47720
b0314d8deee1 dirstate: add a `set_possibly_dirty` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47719
diff changeset
515 @requires_no_parents_change
b0314d8deee1 dirstate: add a `set_possibly_dirty` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47719
diff changeset
516 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
517 """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
518 self._dirty = True
b0314d8deee1 dirstate: add a `set_possibly_dirty` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47719
diff changeset
519 self._updatedfiles.add(filename)
b0314d8deee1 dirstate: add a `set_possibly_dirty` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47719
diff changeset
520 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
521
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
522 @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
523 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
524 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
525 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
526 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
527 ):
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47591
diff changeset
528 """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
529
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47591
diff changeset
530 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
531 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
532
0f5c203eb5ab dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47591
diff changeset
533 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
534 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
535 """
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 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
537 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
538 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
539 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
540 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
541 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
542 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
543 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
544 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
545 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
546 # 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
547 # check it.
47694
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
548 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
549 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
550 # the file is no longer relevant to anyone
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 self._drop(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 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
553 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
554 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
555 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
556 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
557 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
558 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
559
47694
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
560 # 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
561 # 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
562 # 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
563 parentfiledata = None
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
564 if wc_tracked:
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
565 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
566
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
567 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
568 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
569 filename,
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
570 wc_tracked,
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
571 p1_tracked,
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
572 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
573 parentfiledata=parentfiledata,
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
574 )
47696
ff481c238496 dirstate: properly update `_lastnormaltime` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47695
diff changeset
575 if (
ff481c238496 dirstate: properly update `_lastnormaltime` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47695
diff changeset
576 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
577 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
578 ):
ff481c238496 dirstate: properly update `_lastnormaltime` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47695
diff changeset
579 # 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
580 # 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
581 # 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
582 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
583
47611
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
584 @requires_parents_change
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
585 def update_file(
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
586 self,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
587 filename,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
588 wc_tracked,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
589 p1_tracked,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
590 p2_tracked=False,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
591 merged=False,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
592 clean_p1=False,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
593 clean_p2=False,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
594 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
595 parentfiledata=None,
47611
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
596 ):
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
597 """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
598
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
599 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
600 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
601
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
602 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
603
47770
03089463c554 dirstate: fix typo in docstring
Augie Fackler <augie@google.com>
parents: 47757
diff changeset
604 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
605 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
606 other processing.
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
607 """
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
608 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
609 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
610 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
611
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
612 # 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
613 # 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
614 # 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
615
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
616 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
617 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
618
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
619 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
620 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
621 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
622 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
623 )
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
624
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 # 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
626 # 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
627 # 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
628 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
629 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
630 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
631 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
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 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
634 # 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
635 # 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
636 # 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
637 # 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
638 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
639
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 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
641 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
642 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
643 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
644 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
645 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
646 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
647 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
648 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
649 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
650 )
47695
f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47694
diff changeset
651 if (
f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47694
diff changeset
652 parentfiledata is not None
f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47694
diff changeset
653 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
654 ):
f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47694
diff changeset
655 # 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
656 # 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
657 # 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
658 self._lastnormaltime = parentfiledata[2]
47611
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
659
47492
1f571077222d dirstate: add an explicit `from_p2` parameter to `_addpath`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47491
diff changeset
660 def _addpath(
1f571077222d dirstate: add an explicit `from_p2` parameter to `_addpath`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47491
diff changeset
661 self,
1f571077222d dirstate: add an explicit `from_p2` parameter to `_addpath`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47491
diff changeset
662 f,
47525
fe4641cf9b72 dirstate: use a `added` parameter to _addpath
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47524
diff changeset
663 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
664 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
665 mtime=None,
47525
fe4641cf9b72 dirstate: use a `added` parameter to _addpath
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47524
diff changeset
666 added=False,
47527
c6b91a9c242a dirstate: use a `merged` parameter to _addpath
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47526
diff changeset
667 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
668 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
669 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
670 ):
47523
b76d54b90dc9 dirstate: stop using `oldstate` in `dirstate._addpath`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47522
diff changeset
671 entry = self._map.get(f)
47525
fe4641cf9b72 dirstate: use a `added` parameter to _addpath
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47524
diff changeset
672 if added or entry is not None and entry.removed:
13974
23f2736abce3 move checkfilename from util to scmutil
Adrian Buehlmann <adrian@cadifra.com>
parents: 13944
diff changeset
673 scmutil.checkfilename(f)
35107
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35106
diff changeset
674 if self._map.hastrackeddir(f):
47485
f93298a48da1 dirstate: split a not-so-one-liner
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47484
diff changeset
675 msg = _(b'directory %r already in dirstate')
f93298a48da1 dirstate: split a not-so-one-liner
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47484
diff changeset
676 msg %= pycompat.bytestr(f)
f93298a48da1 dirstate: split a not-so-one-liner
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47484
diff changeset
677 raise error.Abort(msg)
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
678 # shadows
43677
0b7733719d21 utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents: 43664
diff changeset
679 for d in pathutil.finddirs(f):
35107
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35106
diff changeset
680 if self._map.hastrackeddir(d):
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
681 break
34200
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34040
diff changeset
682 entry = self._map.get(d)
47515
c94d3ff46fd5 dirstate-entry: add a `removed` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47514
diff changeset
683 if entry is not None and not entry.removed:
47486
612f5f36fcf6 dirstate: split a not-so-one-liner
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47485
diff changeset
684 msg = _(b'file %r in dirstate clashes with %r')
612f5f36fcf6 dirstate: split a not-so-one-liner
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47485
diff changeset
685 msg %= (pycompat.bytestr(d), pycompat.bytestr(f))
612f5f36fcf6 dirstate: split a not-so-one-liner
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47485
diff changeset
686 raise error.Abort(msg)
17094
c2016bae3b97 dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents: 16955
diff changeset
687 self._dirty = True
31216
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31070
diff changeset
688 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
689 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
690 f,
abed645b8e96 dirstate: move the handling of special case within the dirstatemap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47517
diff changeset
691 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
692 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
693 mtime=mtime,
47525
fe4641cf9b72 dirstate: use a `added` parameter to _addpath
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47524
diff changeset
694 added=added,
47527
c6b91a9c242a dirstate: use a `merged` parameter to _addpath
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47526
diff changeset
695 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
696 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
697 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
698 )
5487
7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660).
Maxim Dounin <mdounin@mdounin.ru>
parents: 5396
diff changeset
699
47690
a685c29ebf54 dirstate: factor out the part retrieve "filedata" out of `normal`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47674
diff changeset
700 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
701 """returns"""
a685c29ebf54 dirstate: factor out the part retrieve "filedata" out of `normal`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47674
diff changeset
702 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
703 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
704 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
705 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
706 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
707
42472
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42468
diff changeset
708 def normal(self, f, parentfiledata=None):
45957
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45269
diff changeset
709 """Mark a file normal and clean.
42472
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42468
diff changeset
710
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42468
diff changeset
711 parentfiledata: (mode, size, mtime) of the clean file
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42468
diff changeset
712
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42468
diff changeset
713 parentfiledata should be computed from memory (for mode,
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42468
diff changeset
714 size), as or close as possible from the point where we
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42468
diff changeset
715 determined the file was clean, to limit the risk of the
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42468
diff changeset
716 file having been changed by an external process between the
45957
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45269
diff changeset
717 moment where the file was determined to be clean and now."""
47719
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
718 if self.pendingparentchange():
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
719 util.nouideprecwarn(
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
720 b"do not use `normal` inside of update/merge context."
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
721 b" Use `update_file` or `update_file_p1`",
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
722 b'6.0',
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
723 stacklevel=2,
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
724 )
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
725 else:
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
726 util.nouideprecwarn(
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
727 b"do not use `normal` outside of update/merge context."
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
728 b" Use `set_tracked`",
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
729 b'6.0',
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
730 stacklevel=2,
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
731 )
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
732 self._normal(f, parentfiledata=parentfiledata)
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
733
1168e54b727c dirstate: deprecate the `normal` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47704
diff changeset
734 def _normal(self, f, parentfiledata=None):
42472
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42468
diff changeset
735 if parentfiledata:
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42468
diff changeset
736 (mode, size, mtime) = parentfiledata
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42468
diff changeset
737 else:
47690
a685c29ebf54 dirstate: factor out the part retrieve "filedata" out of `normal`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47674
diff changeset
738 (mode, size, mtime) = self._get_filedata(f)
47530
a1745a292885 dirstate: drop `state` to `_addpath`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47529
diff changeset
739 self._addpath(f, mode=mode, size=size, mtime=mtime)
34343
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34342
diff changeset
740 self._map.copymap.pop(f, None)
34674
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
741 if f in self._map.nonnormalset:
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
742 self._map.nonnormalset.remove(f)
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
743 if mtime > self._lastnormaltime:
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
744 # Remember the most recent modification timeslot for status(),
13754
ae157ca56cd5 dirstate: check mtime when adding to _lastnormal
Adrian Buehlmann <adrian@cadifra.com>
parents: 13743
diff changeset
745 # to make sure we won't miss future size-preserving file content
ae157ca56cd5 dirstate: check mtime when adding to _lastnormal
Adrian Buehlmann <adrian@cadifra.com>
parents: 13743
diff changeset
746 # modifications that happen within the same timeslot.
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
747 self._lastnormaltime = mtime
13704
a464763e99f1 dirstate: avoid a race with multiple commits in the same process
Greg Ward <greg@gerg.ca>
parents: 13400
diff changeset
748
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 def normallookup(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
750 '''Mark a file normal, but possibly dirty.'''
47741
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
751 if self.pendingparentchange():
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
752 util.nouideprecwarn(
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
753 b"do not use `normallookup` inside of update/merge context."
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
754 b" Use `update_file` or `update_file_p1`",
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
755 b'6.0',
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
756 stacklevel=2,
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
757 )
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
758 else:
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
759 util.nouideprecwarn(
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
760 b"do not use `normallookup` outside of update/merge context."
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
761 b" Use `set_possibly_dirty` or `set_tracked`",
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
762 b'6.0',
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
763 stacklevel=2,
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
764 )
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
765 self._normallookup(f)
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
766
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
767 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
768 '''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
769 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
770 # 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
771 # "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
772 # 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
773 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
774 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
775 # 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
776 # (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
777 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
778 source = self._map.copymap.get(f)
47516
b8ffe85e399b dirstate-entry: `merged_removed` and `from_p2_removed` properties
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47515
diff changeset
779 if entry.merged_removed:
47744
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
780 self._merge(f)
47516
b8ffe85e399b dirstate-entry: `merged_removed` and `from_p2_removed` properties
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47515
diff changeset
781 elif entry.from_p2_removed:
47742
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
782 self._otherparent(f)
47516
b8ffe85e399b dirstate-entry: `merged_removed` and `from_p2_removed` properties
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47515
diff changeset
783 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
784 self.copy(source, f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34040
diff changeset
785 return
47517
28632eb3ca3e dirstate-entry: restrict `from_p2` property to tracked file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47516
diff changeset
786 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
787 return
47528
80617f3c0f9a dirstate: infer the 'n' state from `possibly_dirty`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47527
diff changeset
788 self._addpath(f, possibly_dirty=True)
34343
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34342
diff changeset
789 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
790
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
791 def otherparent(self, f):
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
792 '''Mark as coming from the other parent, always dirty.'''
47742
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
793 if self.pendingparentchange():
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
794 util.nouideprecwarn(
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
795 b"do not use `otherparent` inside of update/merge context."
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
796 b" Use `update_file` or `update_file_p1`",
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
797 b'6.0',
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
798 stacklevel=2,
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
799 )
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
800 else:
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
801 util.nouideprecwarn(
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
802 b"do not use `otherparent` outside of update/merge context."
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
803 b"It should have been set by the update/merge code",
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
804 b'6.0',
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
805 stacklevel=2,
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
806 )
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
807 self._otherparent(f)
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
808
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
809 def _otherparent(self, f):
47510
94c58f3aab56 dirstate: add a `in_merge` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47506
diff changeset
810 if not self.in_merge:
47484
e6b303eb8f7d dirstate: split a not-so-one-liner
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47482
diff changeset
811 msg = _(b"setting %r to other parent only allowed in merges") % f
e6b303eb8f7d dirstate: split a not-so-one-liner
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47482
diff changeset
812 raise error.Abort(msg)
47558
811a79bfb8bb dirstate: drop the last explicit `state` usage in the module
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47539
diff changeset
813 entry = self._map.get(f)
811a79bfb8bb dirstate: drop the last explicit `state` usage in the module
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47539
diff changeset
814 if entry is not None and entry.tracked:
22896
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
815 # merge-like
47527
c6b91a9c242a dirstate: use a `merged` parameter to _addpath
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47526
diff changeset
816 self._addpath(f, merged=True)
22896
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
817 else:
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
818 # add-like
47529
d3cf20328abd dirstate: infer the 'n' state from `from_p2`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47528
diff changeset
819 self._addpath(f, from_p2=True)
34343
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34342
diff changeset
820 self._map.copymap.pop(f, None)
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
821
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
822 def add(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
823 '''Mark a file added.'''
47757
7375add1ca92 dirstate: deprecate the `add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47753
diff changeset
824 if self.pendingparentchange():
47661
b2082426f03a dirstate: deprecate the `add` method outside of update/merge context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47612
diff changeset
825 util.nouideprecwarn(
47757
7375add1ca92 dirstate: deprecate the `add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47753
diff changeset
826 b"do not use `add` inside of update/merge context."
7375add1ca92 dirstate: deprecate the `add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47753
diff changeset
827 b" Use `update_file`",
7375add1ca92 dirstate: deprecate the `add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47753
diff changeset
828 b'6.0',
7375add1ca92 dirstate: deprecate the `add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47753
diff changeset
829 stacklevel=2,
7375add1ca92 dirstate: deprecate the `add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47753
diff changeset
830 )
7375add1ca92 dirstate: deprecate the `add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47753
diff changeset
831 else:
7375add1ca92 dirstate: deprecate the `add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47753
diff changeset
832 util.nouideprecwarn(
47777
97acbced3a99 dirstate: use `add` in the deprecation message about `add`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47770
diff changeset
833 b"do not use `add` outside of update/merge context."
47661
b2082426f03a dirstate: deprecate the `add` method outside of update/merge context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47612
diff changeset
834 b" Use `set_tracked`",
b2082426f03a dirstate: deprecate the `add` method outside of update/merge context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47612
diff changeset
835 b'6.0',
b2082426f03a dirstate: deprecate the `add` method outside of update/merge context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47612
diff changeset
836 stacklevel=2,
b2082426f03a dirstate: deprecate the `add` method outside of update/merge context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47612
diff changeset
837 )
47589
f5c24c124e07 dirstate: introduce an internal `_add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47558
diff changeset
838 self._add(f)
f5c24c124e07 dirstate: introduce an internal `_add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47558
diff changeset
839
f5c24c124e07 dirstate: introduce an internal `_add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47558
diff changeset
840 def _add(self, filename):
f5c24c124e07 dirstate: introduce an internal `_add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47558
diff changeset
841 """internal function to mark a file as added"""
f5c24c124e07 dirstate: introduce an internal `_add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47558
diff changeset
842 self._addpath(filename, added=True)
f5c24c124e07 dirstate: introduce an internal `_add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47558
diff changeset
843 self._map.copymap.pop(filename, None)
4616
70352337934e dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents: 4615
diff changeset
844
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
845 def remove(self, f):
47590
c5190adc17d5 dirstate: introduce an internal `_remove` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47589
diff changeset
846 '''Mark a file removed'''
47701
0e87c90f1cd5 dirstate: deprecate `dirstate.remove` in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47696
diff changeset
847 if self.pendingparentchange():
0e87c90f1cd5 dirstate: deprecate `dirstate.remove` in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47696
diff changeset
848 util.nouideprecwarn(
0e87c90f1cd5 dirstate: deprecate `dirstate.remove` in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47696
diff changeset
849 b"do not use `remove` insde of update/merge context."
0e87c90f1cd5 dirstate: deprecate `dirstate.remove` in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47696
diff changeset
850 b" Use `update_file` or `update_file_p1`",
0e87c90f1cd5 dirstate: deprecate `dirstate.remove` in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47696
diff changeset
851 b'6.0',
0e87c90f1cd5 dirstate: deprecate `dirstate.remove` in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47696
diff changeset
852 stacklevel=2,
0e87c90f1cd5 dirstate: deprecate `dirstate.remove` in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47696
diff changeset
853 )
0e87c90f1cd5 dirstate: deprecate `dirstate.remove` in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47696
diff changeset
854 else:
47662
1a79bb8c572c dirstate: deprecated `remove` outside of `update/merge`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47661
diff changeset
855 util.nouideprecwarn(
1a79bb8c572c dirstate: deprecated `remove` outside of `update/merge`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47661
diff changeset
856 b"do not use `remove` outside of update/merge context."
1a79bb8c572c dirstate: deprecated `remove` outside of `update/merge`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47661
diff changeset
857 b" Use `set_untracked`",
1a79bb8c572c dirstate: deprecated `remove` outside of `update/merge`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47661
diff changeset
858 b'6.0',
1a79bb8c572c dirstate: deprecated `remove` outside of `update/merge`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47661
diff changeset
859 stacklevel=2,
1a79bb8c572c dirstate: deprecated `remove` outside of `update/merge`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47661
diff changeset
860 )
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
861 self._dirty = True
47920
6614ab9f061d dirstate: forward `remove` call to newer `API`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47912
diff changeset
862 self._updatedfiles.add(f)
6614ab9f061d dirstate: forward `remove` call to newer `API`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47912
diff changeset
863 entry = self._map.get(f)
6614ab9f061d dirstate: forward `remove` call to newer `API`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47912
diff changeset
864 if entry is None:
6614ab9f061d dirstate: forward `remove` call to newer `API`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47912
diff changeset
865 # Assuming we are in a update/merge case
6614ab9f061d dirstate: forward `remove` call to newer `API`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47912
diff changeset
866 self.update_file(f, p1_tracked=True, wc_tracked=False)
6614ab9f061d dirstate: forward `remove` call to newer `API`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47912
diff changeset
867 else:
6614ab9f061d dirstate: forward `remove` call to newer `API`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47912
diff changeset
868 self.set_untracked(f)
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
869
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
870 def merge(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
871 '''Mark a file merged.'''
47744
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
872 if self.pendingparentchange():
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
873 util.nouideprecwarn(
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
874 b"do not use `merge` inside of update/merge context."
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
875 b" Use `update_file`",
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
876 b'6.0',
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
877 stacklevel=2,
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
878 )
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
879 else:
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
880 util.nouideprecwarn(
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
881 b"do not use `merge` outside of update/merge context."
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
882 b"It should have been set by the update/merge code",
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
883 b'6.0',
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
884 stacklevel=2,
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
885 )
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
886 self._merge(f)
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
887
372ff4638cb4 dirstate: deprecate the `merge` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47742
diff changeset
888 def _merge(self, f):
47510
94c58f3aab56 dirstate: add a `in_merge` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47506
diff changeset
889 if not self.in_merge:
47741
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
890 return self._normallookup(f)
47742
f51aaa0f1485 dirstate: deprecate the `otherparent` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47741
diff changeset
891 return self._otherparent(f)
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
892
14434
cc8c09855d19 dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents: 14273
diff changeset
893 def drop(self, f):
cc8c09855d19 dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents: 14273
diff changeset
894 '''Drop a file from the dirstate'''
47753
aca197f5ef7d dirstate: deprecate the `drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47744
diff changeset
895 if self.pendingparentchange():
aca197f5ef7d dirstate: deprecate the `drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47744
diff changeset
896 util.nouideprecwarn(
aca197f5ef7d dirstate: deprecate the `drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47744
diff changeset
897 b"do not use `drop` inside of update/merge context."
aca197f5ef7d dirstate: deprecate the `drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47744
diff changeset
898 b" Use `update_file`",
aca197f5ef7d dirstate: deprecate the `drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47744
diff changeset
899 b'6.0',
aca197f5ef7d dirstate: deprecate the `drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47744
diff changeset
900 stacklevel=2,
aca197f5ef7d dirstate: deprecate the `drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47744
diff changeset
901 )
aca197f5ef7d dirstate: deprecate the `drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47744
diff changeset
902 else:
47663
6f8d6dd32e61 dirstate: deprecated `drop` outside of `update/merge`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47662
diff changeset
903 util.nouideprecwarn(
6f8d6dd32e61 dirstate: deprecated `drop` outside of `update/merge`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47662
diff changeset
904 b"do not use `drop` outside of update/merge context."
6f8d6dd32e61 dirstate: deprecated `drop` outside of `update/merge`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47662
diff changeset
905 b" Use `set_untracked`",
6f8d6dd32e61 dirstate: deprecated `drop` outside of `update/merge`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47662
diff changeset
906 b'6.0',
6f8d6dd32e61 dirstate: deprecated `drop` outside of `update/merge`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47662
diff changeset
907 stacklevel=2,
6f8d6dd32e61 dirstate: deprecated `drop` outside of `update/merge`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47662
diff changeset
908 )
47591
3d8b639bfbaa dirstate: introduce an internal `_drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47590
diff changeset
909 self._drop(f)
3d8b639bfbaa dirstate: introduce an internal `_drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47590
diff changeset
910
3d8b639bfbaa dirstate: introduce an internal `_drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47590
diff changeset
911 def _drop(self, filename):
3d8b639bfbaa dirstate: introduce an internal `_drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47590
diff changeset
912 """internal function to drop a file from the dirstate"""
3d8b639bfbaa dirstate: introduce an internal `_drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47590
diff changeset
913 if self._map.dropfile(filename):
15399
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents: 15337
diff changeset
914 self._dirty = True
47591
3d8b639bfbaa dirstate: introduce an internal `_drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47590
diff changeset
915 self._updatedfiles.add(filename)
3d8b639bfbaa dirstate: introduce an internal `_drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47590
diff changeset
916 self._map.copymap.pop(filename, None)
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
917
24538
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
918 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
919 if exists is None:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
920 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
921 if not exists:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
922 # Maybe a path component exists
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
923 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
924 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
925 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
926 folded = d + b"/" + f
24538
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
927 else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
928 # No path components, preserve original case
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
929 folded = path
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
930 else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
931 # recursively normalize leading directory components
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
932 # against dirstate
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
933 if b'/' in normed:
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
934 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
935 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
936 r = self._root + b"/" + d
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
937 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
938 else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
939 folded = util.fspath(normed, self._root)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
940 storemap[normed] = folded
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
941
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
942 return folded
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
943
24539
3a8eba78803e dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents: 24538
diff changeset
944 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
945 normed = util.normcase(path)
34676
bfddc3d678ae dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents: 34675
diff changeset
946 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
947 if folded is None:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
948 if isknown:
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
949 folded = path
7068
57377fa7eda2 issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents: 7034
diff changeset
950 else:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
951 folded = self._discoverpath(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
952 path, normed, ignoremissing, exists, self._map.filefoldmap
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
953 )
24539
3a8eba78803e dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents: 24538
diff changeset
954 return folded
16302
49b54f1ae053 dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents: 16258
diff changeset
955
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
956 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
957 normed = util.normcase(path)
34676
bfddc3d678ae dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents: 34675
diff changeset
958 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
959 if folded is None:
34678
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
960 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
961 if folded is None:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
962 if isknown:
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
963 folded = path
7068
57377fa7eda2 issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents: 7034
diff changeset
964 else:
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
965 # 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
966 # normalizefile calls don't start matching directories
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
967 folded = self._discoverpath(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
968 path, normed, ignoremissing, exists, self._map.dirfoldmap
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
969 )
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
970 return folded
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
971
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
972 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
973 """
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
974 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
975
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
976 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
977 disk, to avoid extra filesystem access.
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
978
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
979 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
980 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
981 existing path components.
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
982
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
983 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
984
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
985 - 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
986 - version of name stored on disk
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
987 - version provided via command arguments
45957
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45269
diff changeset
988 """
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
989
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
990 if self._checkcase:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
991 return self._normalize(path, isknown, ignoremissing)
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
992 return path
6677
9865e15febd0 Add a normalize() method to dirstate
Paul Moore <p.f.moore@gmail.com>
parents: 6675
diff changeset
993
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
994 def clear(self):
34933
0217f75b6e59 dirstate: move clear onto dirstatemap class
Durham Goode <durham@fb.com>
parents: 34678
diff changeset
995 self._map.clear()
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
996 self._lastnormaltime = 0
31216
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31070
diff changeset
997 self._updatedfiles.clear()
5123
79373ec3f27d merge with crew-stable
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5045 5065
diff changeset
998 self._dirty = True
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
999
18760
e74704c33e24 strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents: 18663
diff changeset
1000 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
1001 if changedfiles is None:
27176
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
1002 # Rebuild entire dirstate
43897
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1003 to_lookup = allfiles
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1004 to_drop = []
27176
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
1005 lastnormaltime = self._lastnormaltime
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
1006 self.clear()
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
1007 self._lastnormaltime = lastnormaltime
43897
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1008 elif len(changedfiles) < 10:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1009 # 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
1010 # large.
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1011 to_lookup = []
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1012 to_drop = []
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1013 for f in changedfiles:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1014 if f in allfiles:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1015 to_lookup.append(f)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1016 else:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1017 to_drop.append(f)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1018 else:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1019 changedfilesset = set(changedfiles)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1020 to_lookup = changedfilesset & set(allfiles)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1021 to_drop = changedfilesset - to_lookup
27176
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
1022
29783
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29687
diff changeset
1023 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
1024 self._origpl = self._pl
47055
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
1025 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
1026
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1027 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
1028 self._normallookup(f)
43897
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43875
diff changeset
1029 for f in to_drop:
47591
3d8b639bfbaa dirstate: introduce an internal `_drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47590
diff changeset
1030 self._drop(f)
30028
ba06562a06a2 dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents: 29893
diff changeset
1031
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
1032 self._dirty = True
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
1033
32770
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32702
diff changeset
1034 def identity(self):
45957
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45269
diff changeset
1035 """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
1036
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32702
diff changeset
1037 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
1038 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
1039 """
34675
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
1040 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
1041
29687
52ff07e1de91 deprecation: enforce thew 'tr' argument of 'dirstate.write' (API)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 29351
diff changeset
1042 def write(self, tr):
4612
17ee7407097f dirstate: simplify dirty handling
Matt Mackall <mpm@selenic.com>
parents: 4611
diff changeset
1043 if not self._dirty:
1794
98b6c1cad58b only write the dirstate when something changed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1755
diff changeset
1044 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
1045
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
1046 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
1047 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
1048 # '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
1049 # 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
1050 # 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
1051 # 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
1052 # 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
1053
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
1054 # 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
1055 now = _getfsnow(self._opener)
35103
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35102
diff changeset
1056 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
1057
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
1058 # 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
1059 self._lastnormaltime = 0
31216
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31070
diff changeset
1060 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
1061
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
1062 # delay writing in-memory changes out
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1063 tr.addfilegenerator(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1064 b'dirstate',
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1065 (self._filename,),
47674
ff97e793ed36 dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents: 47673
diff changeset
1066 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
1067 location=b'plain',
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1068 )
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
1069 return
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
1070
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1071 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
1072 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
1073
29783
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29687
diff changeset
1074 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
1075 """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
1076
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29687
diff changeset
1077 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
1078 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
1079
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29687
diff changeset
1080 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
1081 with a newer callback.
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29687
diff changeset
1082 """
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29687
diff changeset
1083 self._plchangecallbacks[category] = callback
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29687
diff changeset
1084
47674
ff97e793ed36 dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents: 47673
diff changeset
1085 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
1086 # 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
1087 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
1088 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
1089 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
1090 ):
29783
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29687
diff changeset
1091 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
1092 self._origpl = None
9509
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
1093 # 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
1094 # 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
1095 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
1096
6c6b48aca328 dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents: 27176
diff changeset
1097 # 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
1098 # 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
1099 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
1100 if delaywrite > 0:
27398
c81675776c95 dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents: 27397
diff changeset
1101 # 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
1102 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
1103 if e.need_delay(now):
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1104 import time # to avoid useless import
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1105
27399
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
1106 # 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
1107 # 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
1108 clock = time.time()
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
1109 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
1110 end = start + delaywrite
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
1111 time.sleep(end - clock)
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1112 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
1113 break
27397
6c6b48aca328 dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents: 27176
diff changeset
1114
47674
ff97e793ed36 dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents: 47673
diff changeset
1115 self._map.write(tr, st, now)
21026
7ee03e190c1d dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents: 20632
diff changeset
1116 self._lastnormaltime = 0
34673
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
1117 self._dirty = False
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
1118
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
1119 def _dirignore(self, f):
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
1120 if self._ignore(f):
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
1121 return True
43677
0b7733719d21 utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents: 43664
diff changeset
1122 for p in pathutil.finddirs(f):
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
1123 if self._ignore(p):
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
1124 return True
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
1125 return False
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
1126
27594
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
1127 def _ignorefiles(self):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
1128 files = []
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1129 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
1130 files.append(self._join(b'.hgignore'))
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1131 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
1132 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
1133 # 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
1134 # 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
1135 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
1136 return files
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
1137
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
1138 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
1139 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
1140 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
1141 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
1142 i = files.popleft()
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1143 patterns = matchmod.readpatternfile(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1144 i, self._ui.warn, sourceinfo=True
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1145 )
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
1146 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
1147 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
1148 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
1149 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
1150 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
1151 continue
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1152 m = matchmod.match(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1153 self._root, b'', [], [pattern], warn=self._ui.warn
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1154 )
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
1155 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
1156 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
1157 visited.add(i)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1158 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
1159
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1160 def _walkexplicit(self, match, subrepos):
45957
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45269
diff changeset
1161 """Get stat data about the files explicitly specified by match.
3529
09d99b7e4da0 simplify dirstate walking
Matt Mackall <mpm@selenic.com>
parents: 3223
diff changeset
1162
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
1163 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
1164 - 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
1165 listings mapping subrepos and .hg to None.
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
1166 - 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
1167 - 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
1168 directories and that were not found."""
6578
f242d3684f83 walk: begin refactoring badmatch handling
Matt Mackall <mpm@selenic.com>
parents: 6577
diff changeset
1169
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
1170 def badtype(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1171 kind = _(b'unknown')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
1172 if stat.S_ISCHR(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1173 kind = _(b'character device')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
1174 elif stat.S_ISBLK(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1175 kind = _(b'block device')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
1176 elif stat.S_ISFIFO(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1177 kind = _(b'fifo')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
1178 elif stat.S_ISSOCK(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1179 kind = _(b'socket')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
1180 elif stat.S_ISDIR(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1181 kind = _(b'directory')
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1182 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
1183
8676
acd69fc201a5 walk: we always have a badfn
Matt Mackall <mpm@selenic.com>
parents: 8675
diff changeset
1184 badfn = match.bad
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
1185 dmap = self._map
5000
46facb73ba8b dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents: 4965
diff changeset
1186 lstat = os.lstat
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
1187 getkind = stat.S_IFMT
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
1188 dirkind = stat.S_IFDIR
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
1189 regkind = stat.S_IFREG
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
1190 lnkkind = stat.S_IFLNK
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
1191 join = self._join
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
1192 dirsfound = []
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
1193 foundadd = dirsfound.append
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1194 dirsnotfound = []
19175
63f7bd2e1a46 dirstate._walkexplicit: inline dirsnotfound.append
Siddharth Agarwal <sid0@fb.com>
parents: 19174
diff changeset
1195 notfoundadd = dirsnotfound.append
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
1196
24448
55c449345b10 match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents: 24212
diff changeset
1197 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
1198 normalize = self._normalize
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
1199 else:
18032
a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents: 18018
diff changeset
1200 normalize = None
12907
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
1201
12211
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
1202 files = sorted(match.files())
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
1203 subrepos.sort()
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
1204 i, j = 0, 0
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
1205 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
1206 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
1207 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
1208 i += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
1209 continue
13339
22167be007ed subrepo: fix pruning of subrepo filenames in dirstate (issue2619)
trbs <trbs@trbs.net>
parents: 13233
diff changeset
1210 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
1211 del files[i]
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
1212 j += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
1213
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1214 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
1215 files = [b'']
42362
7ada598941d2 dirstate: move special handling of files==['.'] together
Martin von Zweigbergk <martinvonz@google.com>
parents: 42331
diff changeset
1216 # 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
1217 # common case where files is ['']
42362
7ada598941d2 dirstate: move special handling of files==['.'] together
Martin von Zweigbergk <martinvonz@google.com>
parents: 42331
diff changeset
1218 normalize = None
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
1219 results = dict.fromkeys(subrepos)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1220 results[b'.hg'] = None
5000
46facb73ba8b dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents: 4965
diff changeset
1221
12211
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
1222 for ff in files:
42362
7ada598941d2 dirstate: move special handling of files==['.'] together
Martin von Zweigbergk <martinvonz@google.com>
parents: 42331
diff changeset
1223 if normalize:
24522
18085e46caa9 dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents: 24521
diff changeset
1224 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
1225 else:
24522
18085e46caa9 dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents: 24521
diff changeset
1226 nf = ff
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
1227 if nf in results:
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
1228 continue
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
1229
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
1230 try:
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
1231 st = lstat(join(nf))
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
1232 kind = getkind(st.st_mode)
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
1233 if kind == dirkind:
8588
2624f485b9bc dirstate: set more states in step 1 of walk
Simon Heimberg <simohe@besonet.ch>
parents: 8521
diff changeset
1234 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
1235 # 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
1236 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
1237 foundadd((nf, ff))
12401
4cdaf1adafc8 backout most of 4f8067c94729
Matt Mackall <mpm@selenic.com>
parents: 12387
diff changeset
1238 elif kind == regkind or kind == lnkkind:
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
1239 results[nf] = st
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
1240 else:
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
1241 badfn(ff, badtype(kind))
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
1242 if nf in dmap:
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
1243 results[nf] = None
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1244 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
1245 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
1246 results[nf] = None
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1247 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
1248 if self._map.hasdir(nf):
23375
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
1249 notfoundadd(nf)
8677
34df078b8b1b walk: simplify logic for badfn clause
Matt Mackall <mpm@selenic.com>
parents: 8676
diff changeset
1250 else:
34040
d5b2beca16c0 python3: wrap all uses of <exception>.strerror with strtolocal
Augie Fackler <raf@durin42.com>
parents: 33999
diff changeset
1251 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
1252
36238
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35935
diff changeset
1253 # 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
1254 # 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
1255 # 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
1256 if match.anypats():
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35935
diff changeset
1257 for f in list(results):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1258 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
1259 # 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
1260 continue
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35935
diff changeset
1261 if not match(f):
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35935
diff changeset
1262 del results[f]
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35935
diff changeset
1263
25877
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
1264 # 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
1265 # 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
1266 # 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
1267 # 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
1268 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
1269 normed = {}
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
1270
43106
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents: 43090
diff changeset
1271 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
1272 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
1273 continue
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
1274
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
1275 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
1276 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
1277
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
1278 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
1279 paths = set()
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
1280 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
1281
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
1282 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
1283
43106
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents: 43090
diff changeset
1284 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
1285 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
1286 for path in paths:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1287 folded = self._discoverpath(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1288 path, norm, True, None, self._map.dirfoldmap
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1289 )
25877
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
1290 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
1291 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
1292
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
1293 return results, dirsfound, dirsnotfound
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1294
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
1295 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
1296 """
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1297 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
1298 matched by match.
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1299
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
1300 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
1301
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1302 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
1303 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
1304
45957
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45269
diff changeset
1305 """
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
1306 # 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
1307 # 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
1308 # 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
1309
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1310 if ignored:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1311 ignore = util.never
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1312 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
1313 elif unknown:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
1314 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
1315 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
1316 else:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
1317 # 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
1318 ignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1319 dirignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1320
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1321 matchfn = match.matchfn
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1322 matchalways = match.always()
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1323 matchtdir = match.traversedir
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1324 dmap = self._map
32248
d74b0cff94a9 osutil: proxy through util (and platform) modules (API)
Yuya Nishihara <yuya@tcha.org>
parents: 32226
diff changeset
1325 listdir = util.listdir
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1326 lstat = os.lstat
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1327 dirkind = stat.S_IFDIR
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1328 regkind = stat.S_IFREG
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1329 lnkkind = stat.S_IFLNK
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1330 join = self._join
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1331
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1332 exact = skipstep3 = False
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1333 if match.isexact(): # match.exact
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1334 exact = True
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1335 dirignore = util.always # skip step 2
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1336 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
1337 skipstep3 = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1338
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1339 if not exact and self._checkcase:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1340 normalize = self._normalize
24541
e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents: 24540
diff changeset
1341 normalizefile = self._normalizefile
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1342 skipstep3 = False
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1343 else:
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
1344 normalize = self._normalize
24541
e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents: 24540
diff changeset
1345 normalizefile = None
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1346
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1347 # step 1: find all explicit files
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1348 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
1349 if matchtdir:
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents: 43736
diff changeset
1350 for d in work:
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents: 43736
diff changeset
1351 matchtdir(d[0])
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents: 43736
diff changeset
1352 for d in dirsnotfound:
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents: 43736
diff changeset
1353 matchtdir(d)
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
1354
19172
c6cea2e2031b dirstate.walk: pull skipstep3 out of the explicit walk code
Siddharth Agarwal <sid0@fb.com>
parents: 19171
diff changeset
1355 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
1356 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
1357
6826
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents: 6825
diff changeset
1358 # 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
1359 def traverse(work, alreadynormed):
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1360 wadd = work.append
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1361 while work:
43239
6fcdcea2b03a dirstate: add some traces on listdir calls
Augie Fackler <augie@google.com>
parents: 43117
diff changeset
1362 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
1363 nd = work.pop()
38994
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36998
diff changeset
1364 visitentries = match.visitchildrenset(nd)
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36998
diff changeset
1365 if not visitentries:
32226
8f1a2b848b52 dirstate: optimize walk() by using match.visitdir()
Martin von Zweigbergk <martinvonz@google.com>
parents: 31553
diff changeset
1366 continue
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1367 if visitentries == b'this' or visitentries == b'all':
38994
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36998
diff changeset
1368 visitentries = None
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1369 skip = None
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1370 if nd != b'':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1371 skip = b'.hg'
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1372 try:
43239
6fcdcea2b03a dirstate: add some traces on listdir calls
Augie Fackler <augie@google.com>
parents: 43117
diff changeset
1373 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
1374 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
1375 except OSError as inst:
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1376 if inst.errno in (errno.EACCES, errno.ENOENT):
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1377 match.bad(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1378 self.pathto(nd), encoding.strtolocal(inst.strerror)
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1379 )
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1380 continue
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1381 raise
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1382 for f, kind, st in entries:
39288
27946fca8a05 match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents: 38997
diff changeset
1383 # 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
1384 # 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
1385 # 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
1386 # 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
1387 # 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
1388 # 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
1389 # 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
1390 # they're actually a file or a directory.
38994
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36998
diff changeset
1391 if visitentries and f not in visitentries:
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36998
diff changeset
1392 continue
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1393 if normalizefile:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1394 # 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
1395 # 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
1396 # dmap -- therefore normalizefile is enough
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1397 nf = normalizefile(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1398 nd and (nd + b"/" + f) or f, True, True
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1399 )
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1400 else:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1401 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
1402 if nf not in results:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1403 if kind == dirkind:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1404 if not ignore(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1405 if matchtdir:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1406 matchtdir(nf)
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
1407 wadd(nf)
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1408 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
1409 results[nf] = None
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1410 elif kind == regkind or kind == lnkkind:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1411 if nf in dmap:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1412 if matchalways or matchfn(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1413 results[nf] = st
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1414 elif (matchalways or matchfn(nf)) and not ignore(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1415 nf
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1416 ):
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
1417 # 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
1418 if not alreadynormed:
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
1419 nf = normalize(nf, False, True)
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1420 results[nf] = st
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1421 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
1422 results[nf] = None
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1423
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
1424 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
1425 # 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
1426 # expensive directory normalization
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
1427 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
1428 traverse([d], alreadynormed)
536
c15b4bc0a11c Refactor diffrevs/diffdir into changes
mpm@selenic.com
parents: 529
diff changeset
1429
18812
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18792
diff changeset
1430 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
1431 del results[s]
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1432 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
1433
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
1434 # 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
1435 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
1436 # 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
1437 # 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
1438 # 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
1439 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
1440 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
1441 else:
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
1442 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
1443 visit.sort()
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
1444
18625
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
1445 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
1446 # 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
1447 # 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
1448 # 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
1449 # 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
1450 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
1451
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
1452 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
1453 # 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
1454 # 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
1455 # 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
1456 # on disk.
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1457 if (
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1458 normalizefile
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1459 and normalizefile(nf, True, True) in results
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1460 ):
24621
1784ca148392 dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents: 24537
diff changeset
1461 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
1462 # 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
1463 # 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
1464 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
1465 try:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
1466 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
1467 # 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
1468 except OSError:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
1469 # file doesn't exist
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
1470 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
1471 else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
1472 # 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
1473 # 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
1474 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
1475 else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
1476 # 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
1477 # 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
1478 iv = iter(visit)
26984
af2663680e95 dirstate: back out 502b56a9e897
Bryan O'Sullivan <bos@serpentine.com>
parents: 26887
diff changeset
1479 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
1480 results[next(iv)] = st
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
1481 return results
669
8aa2a282eda4 .hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents: 667
diff changeset
1482
44540
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1483 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
1484 # 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
1485 # 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
1486 # 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
1487 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
1488 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
1489 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
1490
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Rapha?l Gom?s <rgomes@octobus.net>
parents: 43923
diff changeset
1491 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
1492 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
1493 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
1494
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Rapha?l Gom?s <rgomes@octobus.net>
parents: 43923
diff changeset
1495 (
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Rapha?l Gom?s <rgomes@octobus.net>
parents: 43923
diff changeset
1496 lookup,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Rapha?l Gom?s <rgomes@octobus.net>
parents: 43923
diff changeset
1497 modified,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Rapha?l Gom?s <rgomes@octobus.net>
parents: 43923
diff changeset
1498 added,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Rapha?l Gom?s <rgomes@octobus.net>
parents: 43923
diff changeset
1499 removed,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Rapha?l Gom?s <rgomes@octobus.net>
parents: 43923
diff changeset
1500 deleted,
44540
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1501 clean,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1502 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
1503 unknown,
44540
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1504 warnings,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1505 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
1506 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
1507 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
1508 ) = 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
1509 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
1510 matcher,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Rapha?l Gom?s <rgomes@octobus.net>
parents: 43923
diff changeset
1511 self._rootdir,
44540
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1512 self._ignorefiles(),
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1513 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
1514 self._lastnormaltime,
44540
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1515 bool(list_clean),
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1516 bool(list_ignored),
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1517 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
1518 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
1519 )
44899
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44895
diff changeset
1520
47356
04d1f17f49e7 dirstate-v2: Write .hg/dirstate back to disk on directory cache changes
Simon Sapin <simon.sapin@octobus.net>
parents: 47328
diff changeset
1521 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
1522
44899
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44895
diff changeset
1523 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
1524 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
1525 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
1526
44540
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1527 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
1528 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
1529 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
1530 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
1531 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
1532 file_path,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1533 syntax,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1534 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1535 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
1536 else:
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1537 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
1538 self._ui.warn(
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1539 msg
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1540 % (
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1541 pathutil.canonpath(
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1542 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
1543 ),
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1544 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
1545 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1546 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1547
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1548 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
1549 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
1550
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Rapha?l Gom?s <rgomes@octobus.net>
parents: 43923
diff changeset
1551 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
1552 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
1553 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
1554 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
1555 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
1556 unknown=unknown,
44540
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1557 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
1558 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
1559 )
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Rapha?l Gom?s <rgomes@octobus.net>
parents: 43923
diff changeset
1560 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
1561
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
1562 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
1563 """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
1564 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
1565 scmutil.status and:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
1566
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
1567 unsure:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
1568 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
1569 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
1570 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
1571 status.modified:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
1572 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
1573 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
1574 status.clean:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
1575 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
1576 dirstate was written
45957
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45269
diff changeset
1577 """
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
1578 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
1579 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
1580 removed, deleted, clean = [], [], []
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
1581
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1582 dmap = self._map
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1583 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
1584
733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Rapha?l Gom?s <rgomes@octobus.net>
parents: 43239
diff changeset
1585 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
1586
44540
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1587 allowed_matchers = (
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1588 matchmod.alwaysmatcher,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1589 matchmod.exactmatcher,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1590 matchmod.includematcher,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1591 )
43923
40fd1ef4e4c1 rust-matchers: add support for `exactmatcher` in `dirstate.status`
Rapha?l Gom?s <rgomes@octobus.net>
parents: 43897
diff changeset
1592
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
1593 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
1594 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
1595 elif self._checkcase:
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1596 # 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
1597 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
1598 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
1599 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
1600 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
1601 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
1602 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
1603 # 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
1604 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
1605
733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Rapha?l Gom?s <rgomes@octobus.net>
parents: 43239
diff changeset
1606 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
1607 try:
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1608 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
1609 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
1610 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1611 except rustmod.FallbackError:
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1612 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
1613
43664
dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents: 43656
diff changeset
1614 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
1615 pass
dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents: 43656
diff changeset
1616
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1617 dcontains = dmap.__contains__
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1618 dget = dmap.__getitem__
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1619 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
1620 madd = modified.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1621 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
1622 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
1623 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
1624 radd = removed.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1625 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
1626 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
1627 mexact = match.exact
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
1628 dirignore = self._dirignore
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
1629 checkexec = self._checkexec
34343
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34342
diff changeset
1630 copymap = self._map.copymap
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
1631 lastnormaltime = self._lastnormaltime
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1632
19191
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
1633 # 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
1634 # - we're listing all clean files, or
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
1635 # - 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
1636 # 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
1637 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
1638 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
1639 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
1640 ):
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1641 if not dcontains(fn):
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
1642 if (listignored or mexact(fn)) and dirignore(fn):
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
1643 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
1644 iadd(fn)
19910
601944f41257 dirstate.status: return explicit unknown files even when not asked
Siddharth Agarwal <sid0@fb.com>
parents: 19651
diff changeset
1645 else:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1646 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
1647 continue
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
1648
21810
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
1649 # 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
1650 # 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
1651 # 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
1652 # 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
1653 # 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
1654 # 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
1655 # 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
1656 t = dget(fn)
47536
8e4b9fe31334 dirstate-entry: add a `mode` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47535
diff changeset
1657 mode = t.mode
47537
0e5800c88eb4 dirstate-entry: add a `size` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47536
diff changeset
1658 size = t.size
47538
77fce401a2bb dirstate-entry: add a `mtime` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47537
diff changeset
1659 time = t.mtime
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
1660
47531
f5b8f0b9c129 dirstate-entry: add a `tracked` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47530
diff changeset
1661 if not st and t.tracked:
6818
6e93fbd847ef dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents: 6811
diff changeset
1662 dadd(fn)
47533
174d0bcce2eb dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47532
diff changeset
1663 elif t.merged:
174d0bcce2eb dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47532
diff changeset
1664 madd(fn)
174d0bcce2eb dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47532
diff changeset
1665 elif t.added:
174d0bcce2eb dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47532
diff changeset
1666 aadd(fn)
174d0bcce2eb dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47532
diff changeset
1667 elif t.removed:
174d0bcce2eb dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47532
diff changeset
1668 radd(fn)
47534
e53a42dce923 dirstate: drop last explicite `state` usage in status
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47533
diff changeset
1669 elif t.tracked:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1670 if (
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1671 size >= 0
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1672 and (
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1673 (size != st.st_size and size != st.st_size & _rangemask)
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1674 or ((mode ^ st.st_mode) & 0o100 and checkexec)
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1675 )
47514
559aee84b889 dirstate-entry: add a `from_p2` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47513
diff changeset
1676 or t.from_p2
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1677 or fn in copymap
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1678 ):
46410
ca69e29a2a30 formatting: fix redundant parentheses
Rapha?l Gom?s <rgomes@octobus.net>
parents: 46385
diff changeset
1679 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
1680 # 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
1681 # 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
1682 ladd(fn)
0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt
Corey Schuhen <cschuhen@topcon.com>
parents: 45957
diff changeset
1683 else:
0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt
Corey Schuhen <cschuhen@topcon.com>
parents: 45957
diff changeset
1684 madd(fn)
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1685 elif (
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1686 time != st[stat.ST_MTIME]
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1687 and time != st[stat.ST_MTIME] & _rangemask
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1688 ):
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1689 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
1690 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
1691 # 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
1692 # 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
1693 # This can happen if we quickly do multiple commits.
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
1694 # 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
1695 ladd(fn)
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
1696 elif listclean:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1697 cadd(fn)
44540
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1698 status = scmutil.status(
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1699 modified, added, removed, deleted, unknown, ignored, clean
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1700 )
44540
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44391
diff changeset
1701 return (lookup, status)
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1702
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1703 def matches(self, match):
45957
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45269
diff changeset
1704 """
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1705 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
1706 """
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1707 dmap = self._map
44391
bed8d08cfcb2 rust-dirstatemap: remove additional lookup in dirstate.matches
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44181
diff changeset
1708 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
1709 dmap = self._map._rustmap
bed8d08cfcb2 rust-dirstatemap: remove additional lookup in dirstate.matches
Rapha?l Gom?s <rgomes@octobus.net>
parents: 44181
diff changeset
1710
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1711 if match.always():
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1712 return dmap.keys()
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1713 files = match.files()
24448
55c449345b10 match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents: 24212
diff changeset
1714 if match.isexact():
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1715 # 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
1716 # much smaller than dmap
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1717 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
1718 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
1719 # 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
1720 # that
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1721 return list(files)
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1722 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
1723
26746
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
1724 def _actualfilename(self, tr):
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
1725 if tr:
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1726 return self._pendingfilename
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1727 else:
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1728 return self._filename
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1729
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1730 def savebackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1731 '''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
1732 filename = self._actualfilename(tr)
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1733 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
1734
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1735 # 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
1736 # 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
1737 # 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
1738 if self._dirty or not self._opener.exists(filename):
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1739 self._writedirstate(
47674
ff97e793ed36 dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents: 47673
diff changeset
1740 tr,
ff97e793ed36 dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents: 47673
diff changeset
1741 self._opener(filename, b"w", atomictemp=True, checkambig=True),
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1742 )
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1743
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1744 if tr:
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1745 # 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
1746 # 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
1747 # changed after this
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1748 tr.addfilegenerator(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1749 b'dirstate',
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1750 (self._filename,),
47674
ff97e793ed36 dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents: 47673
diff changeset
1751 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
1752 location=b'plain',
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1753 )
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1754
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1755 # 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
1756 # 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
1757 # end of this transaction
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1758 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
1759
31553
ddadb6b0b58e dirstate: use tryunlink
Ryan McElroy <rmcelroy@fb.com>
parents: 31514
diff changeset
1760 self._opener.tryunlink(backupname)
31217
1ef37b16b8e8 dirstate: try to use hardlink to backup dirstate
Jun Wu <quark@fb.com>
parents: 31216
diff changeset
1761 # 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
1762 # with an "atomictemp=True" file.
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1763 util.copyfile(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1764 self._opener.join(filename),
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1765 self._opener.join(backupname),
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1766 hardlink=True,
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42931
diff changeset
1767 )
26632
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26630
diff changeset
1768
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1769 def restorebackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1770 '''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
1771 # 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
1772 # 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
1773 self.invalidate()
26746
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
1774 filename = self._actualfilename(tr)
34940
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
1775 o = self._opener
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
1776 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
1777 o.unlink(backupname)
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
1778 else:
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
1779 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
1780
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1781 def clearbackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1782 '''Clear backup file'''
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1783 self._opener.unlink(backupname)