mercurial/dirstate.py
author Pierre-Yves David <pierre-yves.david@octobus.net>
Thu, 02 Sep 2021 03:59:35 +0200
changeset 47974 4e6f27230aee
parent 47973 2e0ff3947b05
child 47982 36c0d738c330
permissions -rw-r--r--
dirstate: introduce a `set_clean` method on dirstate's map and items This method is the "reverse" of "set possibly dirty", and can be used to more accurately other call that the dirstate was making. It is currently heavily influenced by its origin. Differential Revision: https://phab.mercurial-scm.org/D11421
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
8226
8b2cd04a6e97 put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents: 8225
diff changeset
     1
# dirstate.py - working directory tracking for mercurial
8b2cd04a6e97 put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents: 8225
diff changeset
     2
#
46819
d4ba4d51f85f contributor: change mentions of mpm to olivia
Raphaël Gomès <rgomes@octobus.net>
parents: 46794
diff changeset
     3
# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
8226
8b2cd04a6e97 put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents: 8225
diff changeset
     4
#
8b2cd04a6e97 put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents: 8225
diff changeset
     5
# This software may be used and distributed according to the terms of the
10263
25e572394f5c Update license to GPLv2+
Matt Mackall <mpm@selenic.com>
parents: 9678
diff changeset
     6
# GNU General Public License version 2 or any later version.
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
     7
27503
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
     8
from __future__ import absolute_import
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
     9
27670
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
    10
import collections
32346
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
    11
import contextlib
27503
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    12
import errno
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    13
import os
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    14
import stat
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    15
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    16
from .i18n import _
43090
1f339b503a40 py3: manually import pycompat.delattr where it is needed
Gregory Szorc <gregory.szorc@gmail.com>
parents: 43077
diff changeset
    17
from .pycompat import delattr
43239
6fcdcea2b03a dirstate: add some traces on listdir calls
Augie Fackler <augie@google.com>
parents: 43117
diff changeset
    18
6fcdcea2b03a dirstate: add some traces on listdir calls
Augie Fackler <augie@google.com>
parents: 43117
diff changeset
    19
from hgdemandimport import tracing
6fcdcea2b03a dirstate: add some traces on listdir calls
Augie Fackler <augie@google.com>
parents: 43117
diff changeset
    20
27503
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    21
from . import (
47501
8b7e47802deb dirstate: split dirstatemap in its own file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47489
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,
32372
df448de7cf3b parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents: 32352
diff changeset
    27
    policy,
30304
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,
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
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
42927
d459cd8ea42d interfaces: introduce an interface for dirstate implementations
Augie Fackler <augie@google.com>
parents: 42755
diff changeset
    34
from .interfaces import (
d459cd8ea42d interfaces: introduce an interface for dirstate implementations
Augie Fackler <augie@google.com>
parents: 42755
diff changeset
    35
    dirstate as intdirstate,
d459cd8ea42d interfaces: introduce an interface for dirstate implementations
Augie Fackler <augie@google.com>
parents: 42755
diff changeset
    36
    util as interfaceutil,
d459cd8ea42d interfaces: introduce an interface for dirstate implementations
Augie Fackler <augie@google.com>
parents: 42755
diff changeset
    37
)
d459cd8ea42d interfaces: introduce an interface for dirstate implementations
Augie Fackler <augie@google.com>
parents: 42755
diff changeset
    38
43506
9f70512ae2cf cleanup: remove pointless r-prefixes on single-quoted strings
Augie Fackler <augie@google.com>
parents: 43505
diff changeset
    39
parsers = policy.importmod('parsers')
9f70512ae2cf cleanup: remove pointless r-prefixes on single-quoted strings
Augie Fackler <augie@google.com>
parents: 43505
diff changeset
    40
rustmod = policy.importrust('dirstate')
32372
df448de7cf3b parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents: 32352
diff changeset
    41
47277
ed0d54b20c5b dirstate-v2: Add a new experimental `exp-dirstate-v2` repository requirement
Simon Sapin <simon.sapin@octobus.net>
parents: 47122
diff changeset
    42
SUPPORTS_DIRSTATE_V2 = rustmod is not None
ed0d54b20c5b dirstate-v2: Add a new experimental `exp-dirstate-v2` repository requirement
Simon Sapin <simon.sapin@octobus.net>
parents: 47122
diff changeset
    43
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    44
propertycache = util.propertycache
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    45
filecache = scmutil.filecache
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
47482
cb29484eaade dirstate: introduce a symbolic constant for the FROM_P2 marker
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47481
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: 42927
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: 42927
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: 42927
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: 42927
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:
36781
ffa3026d4196 cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime
Augie Fackler <augie@google.com>
parents: 36622
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: 42927
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
42927
d459cd8ea42d interfaces: introduce an interface for dirstate implementations
Augie Fackler <augie@google.com>
parents: 42755
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):
46780
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
diff changeset
    99
    def __init__(
47280
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents: 47277
diff changeset
   100
        self,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents: 47277
diff changeset
   101
        opener,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents: 47277
diff changeset
   102
        ui,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents: 47277
diff changeset
   103
        root,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents: 47277
diff changeset
   104
        validate,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents: 47277
diff changeset
   105
        sparsematchfn,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents: 47277
diff changeset
   106
        nodeconstants,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents: 47277
diff changeset
   107
        use_dirstate_v2,
46780
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
diff changeset
   108
    ):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
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.
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
   114
        """
47280
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents: 47277
diff changeset
   115
        self._use_dirstate_v2 = use_dirstate_v2
46780
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
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
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   131
        self._plchangecallbacks = {}
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   132
        self._origpl = None
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
   133
        self._updatedfiles = set()
47501
8b7e47802deb dirstate: split dirstatemap in its own file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47489
diff changeset
   134
        self._mapcls = dirstatemap.dirstatemap
41674
e178b131906a dirstate: call and cache os.getcwd() in constructor
Martin von Zweigbergk <martinvonz@google.com>
parents: 40424
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: 40424
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: 40424
diff changeset
   137
        # raises an exception).
e178b131906a dirstate: call and cache os.getcwd() in constructor
Martin von Zweigbergk <martinvonz@google.com>
parents: 40424
diff changeset
   138
        self._cwd
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   139
44826
35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44825
diff changeset
   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: 44825
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: 44825
diff changeset
   142
35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44825
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: 44825
diff changeset
   144
        """
35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44825
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: 44825
diff changeset
   146
32346
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
   147
    @contextlib.contextmanager
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
   148
    def parentchange(self):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
   149
        """Context manager for handling dirstate parents.
32346
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
   150
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
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: 32208
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: 32208
diff changeset
   153
        released.
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
   154
        """
32346
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
   155
        self._parentwriters += 1
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
   156
        yield
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
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: 32208
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: 32208
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: 32208
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: 32208
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: 32208
diff changeset
   162
        self._parentwriters -= 1
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
   163
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   164
    def pendingparentchange(self):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
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.
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
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):
35078
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
   172
        """Return the dirstate contents (see documentation for dirstatemap)."""
46780
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
diff changeset
   173
        self._map = self._mapcls(
47280
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents: 47277
diff changeset
   174
            self._ui,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents: 47277
diff changeset
   175
            self._opener,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents: 47277
diff changeset
   176
            self._root,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents: 47277
diff changeset
   177
            self._nodeconstants,
1766130fe9ba dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents: 47277
diff changeset
   178
            self._use_dirstate_v2,
46780
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
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
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
   204
    @property
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   205
    def _pl(self):
34338
0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class
Durham Goode <durham@fb.com>
parents: 34337
diff changeset
   206
        return self._map.parents()
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   207
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
   208
    def hasdir(self, d):
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
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:
41676
0531dff73d0b match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents: 41674
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):
44801
373dd22ae60e dirstate: force _checkexec to return a bool
Mitchell Plamann <mplamann@janestreet.com>
parents: 44530
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: 42927
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: 42927
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: 42927
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: 42927
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: 42927
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: 42927
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: 32772
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: 32772
diff changeset
   285
        if forcecwd:
b7f6885cb055 dirstate: centralize _cwd handling into _cwd method
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32772
diff changeset
   286
            return forcecwd
39818
24e493ec2229 py3: rename pycompat.getcwd() to encoding.getcwd() (API)
Matt Harbison <matt_harbison@yahoo.com>
parents: 39452
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):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
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.
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
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):
30614
cfe66dcf45c0 py3: replace os.sep with pycompat.ossep (part 2 of 4)
Pulkit Goyal <7895pulkit@gmail.com>
parents: 30519
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: 42927
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):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
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.
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
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):
33707
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
32550
b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents: 32372
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
32550
b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents: 32372
diff changeset
   345
    iteritems = items
b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents: 32372
diff changeset
   346
47351
3b9914b28133 dirstate-v2: Add --dirs to debugdirstate command
Simon Sapin <simon.sapin@octobus.net>
parents: 47350
diff changeset
   347
    def directories(self):
3b9914b28133 dirstate-v2: Add --dirs to debugdirstate command
Simon Sapin <simon.sapin@octobus.net>
parents: 47350
diff changeset
   348
        return self._map.directories()
3b9914b28133 dirstate-v2: Add --dirs to debugdirstate command
Simon Sapin <simon.sapin@octobus.net>
parents: 47350
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: 47501
diff changeset
   359
    @property
94c58f3aab56 dirstate: add a `in_merge` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47501
diff changeset
   360
    def in_merge(self):
94c58f3aab56 dirstate: add a `in_merge` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47501
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: 47501
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: 47501
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
47012
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
        """
47012
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: 42927
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: 42927
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
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
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]
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
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: 29673
diff changeset
   387
            self._origpl = self._pl
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
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 = {}
47012
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
        ):
47094
e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets
Simon Sapin <simon.sapin@octobus.net>
parents: 47012
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: 47012
diff changeset
   395
31278
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31208
diff changeset
   396
            for f in candidatefiles:
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31208
diff changeset
   397
                s = self._map.get(f)
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31208
diff changeset
   398
                if s is None:
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31208
diff changeset
   399
                    continue
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31208
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:
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   403
                    source = self._map.copymap.get(f)
33981
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 33737
diff changeset
   404
                    if source:
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 33737
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:
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   409
                    source = self._map.copymap.get(f)
33981
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 33737
diff changeset
   410
                    if source:
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 33737
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):
40424
7caf632e30c3 filecache: unimplement __set__() and __delete__() (API)
Yuya Nishihara <yuya@tcha.org>
parents: 39818
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: 42927
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):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
   432
        """Causes the next access to reread the dirstate.
32682
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32605
diff changeset
   433
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32605
diff changeset
   434
        This is different from localrepo.invalidatedirstate() because it always
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32605
diff changeset
   435
        rereads the dirstate. Use localrepo.invalidatedirstate() if you want to
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
   436
        check whether the dirstate has changed before rereading it."""
32682
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32605
diff changeset
   437
43503
313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings
Augie Fackler <augie@google.com>
parents: 43456
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
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
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
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
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:
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   453
            self._map.copymap[dest] = source
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
   454
            self._updatedfiles.add(source)
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
   455
            self._updatedfiles.add(dest)
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   456
        elif self._map.copymap.pop(dest, None):
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
   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):
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
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):
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
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
        """
47972
5a6c1ef4bcac dirstate: make dirstatemap.set_untracked deal with added file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47971
diff changeset
   496
        ret = self._map.set_untracked(filename)
5a6c1ef4bcac dirstate: make dirstatemap.set_untracked deal with added file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47971
diff changeset
   497
        if ret:
47861
1c797757f5bb dirstate: directly call the dirstatemap in `set_untracked`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47778
diff changeset
   498
            self._dirty = True
1c797757f5bb dirstate: directly call the dirstatemap in `set_untracked`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47778
diff changeset
   499
            self._updatedfiles.add(filename)
47972
5a6c1ef4bcac dirstate: make dirstatemap.set_untracked deal with added file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47971
diff changeset
   500
        return ret
47599
cce51119bfe6 dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47594
diff changeset
   501
47704
8a50fb0784a9 dirstate: introduce a `set_clean` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47701
diff changeset
   502
    @requires_no_parents_change
8a50fb0784a9 dirstate: introduce a `set_clean` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47701
diff changeset
   503
    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
   504
        """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
   505
        self._dirty = True
8a50fb0784a9 dirstate: introduce a `set_clean` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47701
diff changeset
   506
        self._updatedfiles.add(filename)
47917
1b3c753b62c6 dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47916
diff changeset
   507
        if parentfiledata:
1b3c753b62c6 dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47916
diff changeset
   508
            (mode, size, mtime) = parentfiledata
1b3c753b62c6 dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47916
diff changeset
   509
        else:
1b3c753b62c6 dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47916
diff changeset
   510
            (mode, size, mtime) = self._get_filedata(filename)
47974
4e6f27230aee dirstate: introduce a `set_clean` method on dirstate's map and items
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47973
diff changeset
   511
        if not self._map[filename].tracked:
4e6f27230aee dirstate: introduce a `set_clean` method on dirstate's map and items
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47973
diff changeset
   512
            self._check_new_tracked_filename(filename)
4e6f27230aee dirstate: introduce a `set_clean` method on dirstate's map and items
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47973
diff changeset
   513
        self._map.set_clean(filename, mode, size, mtime)
47917
1b3c753b62c6 dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47916
diff changeset
   514
        if mtime > self._lastnormaltime:
1b3c753b62c6 dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47916
diff changeset
   515
            # Remember the most recent modification timeslot for status(),
1b3c753b62c6 dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47916
diff changeset
   516
            # to make sure we won't miss future size-preserving file content
1b3c753b62c6 dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47916
diff changeset
   517
            # modifications that happen within the same timeslot.
1b3c753b62c6 dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47916
diff changeset
   518
            self._lastnormaltime = mtime
47704
8a50fb0784a9 dirstate: introduce a `set_clean` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47701
diff changeset
   519
47720
b0314d8deee1 dirstate: add a `set_possibly_dirty` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47719
diff changeset
   520
    @requires_no_parents_change
b0314d8deee1 dirstate: add a `set_possibly_dirty` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47719
diff changeset
   521
    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
   522
        """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
   523
        self._dirty = True
b0314d8deee1 dirstate: add a `set_possibly_dirty` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47719
diff changeset
   524
        self._updatedfiles.add(filename)
b0314d8deee1 dirstate: add a `set_possibly_dirty` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47719
diff changeset
   525
        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
   526
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
   527
    @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
   528
    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
   529
        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
   530
        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
   531
        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
   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
        """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
   534
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
        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
   536
        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
   537
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
        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
   539
        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
   540
        """
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
        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
   542
            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
   543
            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
   544
        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
   545
        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
   546
            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
   547
        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
   548
            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
   549
        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
   550
        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
   551
            # 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
   552
            # check it.
47694
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
   553
            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
   554
        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
   555
            # 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
   556
            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
   557
        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
   558
            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
   559
                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
   560
        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
   561
            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
   562
        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
   563
            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
   564
47694
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
   565
        # 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
   566
        # 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
   567
        # 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
   568
        parentfiledata = None
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
   569
        if wc_tracked:
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
   570
            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
   571
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
   572
        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
   573
        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
   574
            filename,
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
   575
            wc_tracked,
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
   576
            p1_tracked,
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
   577
            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
   578
            parentfiledata=parentfiledata,
1c06ef8f5ea5 dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47693
diff changeset
   579
        )
47696
ff481c238496 dirstate: properly update `_lastnormaltime` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47695
diff changeset
   580
        if (
ff481c238496 dirstate: properly update `_lastnormaltime` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47695
diff changeset
   581
            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
   582
            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
   583
        ):
ff481c238496 dirstate: properly update `_lastnormaltime` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47695
diff changeset
   584
            # 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
   585
            # 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
   586
            # 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
   587
            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
   588
47611
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   589
    @requires_parents_change
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   590
    def update_file(
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   591
        self,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   592
        filename,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   593
        wc_tracked,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   594
        p1_tracked,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   595
        p2_tracked=False,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   596
        merged=False,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   597
        clean_p1=False,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   598
        clean_p2=False,
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   599
        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
   600
        parentfiledata=None,
47611
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
        """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
   603
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   604
        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
   605
        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
   606
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   607
        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
   608
47771
03089463c554 dirstate: fix typo in docstring
Augie Fackler <augie@google.com>
parents: 47757
diff changeset
   609
        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
   610
        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
   611
        other processing.
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   612
        """
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   613
        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
   614
            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
   615
            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
   616
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
        # 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
   618
        # 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
   619
        # 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
   620
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
        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
   622
        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
   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
        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
   625
            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
   626
            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
   627
            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
   628
        )
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47691
diff changeset
   629
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47691
diff changeset
   630
        # 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
   631
        # 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
   632
        # 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
   633
        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
   634
            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
   635
                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
   636
            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
   637
e5fb14a07866 dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47691
diff changeset
   638
            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
   639
                # 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
   640
                # 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
   641
                # 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
   642
                # 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
   643
                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
   644
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
        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
   646
            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
   647
            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
   648
            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
   649
            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
   650
            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
   651
            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
   652
            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
   653
            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
   654
            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
   655
        )
47695
f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47694
diff changeset
   656
        if (
f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47694
diff changeset
   657
            parentfiledata is not None
f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47694
diff changeset
   658
            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
   659
        ):
f98145ce78d7 dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47694
diff changeset
   660
            # 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
   661
            # 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
   662
            # 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
   663
            self._lastnormaltime = parentfiledata[2]
47611
e2e72daac90b dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47599
diff changeset
   664
47487
1f571077222d dirstate: add an explicit `from_p2` parameter to `_addpath`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47486
diff changeset
   665
    def _addpath(
1f571077222d dirstate: add an explicit `from_p2` parameter to `_addpath`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47486
diff changeset
   666
        self,
1f571077222d dirstate: add an explicit `from_p2` parameter to `_addpath`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47486
diff changeset
   667
        f,
47525
fe4641cf9b72 dirstate: use a `added` parameter to _addpath
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47524
diff changeset
   668
        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
   669
        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
   670
        mtime=None,
47525
fe4641cf9b72 dirstate: use a `added` parameter to _addpath
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47524
diff changeset
   671
        added=False,
47527
c6b91a9c242a dirstate: use a `merged` parameter to _addpath
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47526
diff changeset
   672
        merged=False,
47487
1f571077222d dirstate: add an explicit `from_p2` parameter to `_addpath`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47486
diff changeset
   673
        from_p2=False,
47488
91520abe2b2c dirstate: add an explicit `possibly_dirty` parameter to `_addpath`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47487
diff changeset
   674
        possibly_dirty=False,
47487
1f571077222d dirstate: add an explicit `from_p2` parameter to `_addpath`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47486
diff changeset
   675
    ):
47523
b76d54b90dc9 dirstate: stop using `oldstate` in `dirstate._addpath`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47522
diff changeset
   676
        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
   677
        if added or entry is not None and entry.removed:
47973
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   678
            self._check_new_tracked_filename(f)
17094
c2016bae3b97 dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents: 16955
diff changeset
   679
        self._dirty = True
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
   680
        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
   681
        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
   682
            f,
abed645b8e96 dirstate: move the handling of special case within the dirstatemap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47517
diff changeset
   683
            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
   684
            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
   685
            mtime=mtime,
47525
fe4641cf9b72 dirstate: use a `added` parameter to _addpath
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47524
diff changeset
   686
            added=added,
47527
c6b91a9c242a dirstate: use a `merged` parameter to _addpath
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47526
diff changeset
   687
            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
   688
            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
   689
            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
   690
        )
5487
7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660).
Maxim Dounin <mdounin@mdounin.ru>
parents: 5396
diff changeset
   691
47973
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   692
    def _check_new_tracked_filename(self, filename):
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   693
        scmutil.checkfilename(filename)
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   694
        if self._map.hastrackeddir(filename):
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   695
            msg = _(b'directory %r already in dirstate')
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   696
            msg %= pycompat.bytestr(filename)
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   697
            raise error.Abort(msg)
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   698
        # shadows
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   699
        for d in pathutil.finddirs(filename):
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   700
            if self._map.hastrackeddir(d):
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   701
                break
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   702
            entry = self._map.get(d)
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   703
            if entry is not None and not entry.removed:
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   704
                msg = _(b'file %r in dirstate clashes with %r')
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   705
                msg %= (pycompat.bytestr(d), pycompat.bytestr(filename))
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   706
                raise error.Abort(msg)
2e0ff3947b05 dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47972
diff changeset
   707
47690
a685c29ebf54 dirstate: factor out the part retrieve "filedata" out of `normal`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47674
diff changeset
   708
    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
   709
        """returns"""
a685c29ebf54 dirstate: factor out the part retrieve "filedata" out of `normal`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47674
diff changeset
   710
        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
   711
        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
   712
        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
   713
        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
   714
        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
   715
47741
9f19d9f2d191 dirstate: deprecate the `normallookup` method in all cases
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47731
diff changeset
   716
    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
   717
        '''Mark a file normal, but possibly dirty.'''
47510
94c58f3aab56 dirstate: add a `in_merge` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47501
diff changeset
   718
        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
   719
            # 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
   720
            # "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
   721
            # being removed, restore that state.
34188
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   722
            entry = self._map.get(f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   723
            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
   724
                # 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
   725
                # (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
   726
                if entry.merged_removed or entry.from_p2_removed:
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   727
                    source = self._map.copymap.get(f)
47918
496a8e383aeb dirstate: drop the `_otherparent` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47917
diff changeset
   728
                    self._addpath(f, from_p2=True)
496a8e383aeb dirstate: drop the `_otherparent` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47917
diff changeset
   729
                    self._map.copymap.pop(f, None)
47516
b8ffe85e399b dirstate-entry: `merged_removed` and `from_p2_removed` properties
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47515
diff changeset
   730
                    if source is not None:
34188
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   731
                        self.copy(source, f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   732
                    return
47517
28632eb3ca3e dirstate-entry: restrict `from_p2` property to tracked file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47516
diff changeset
   733
                elif entry.merged or entry.from_p2:
34188
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   734
                    return
47528
80617f3c0f9a dirstate: infer the 'n' state from `possibly_dirty`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47527
diff changeset
   735
        self._addpath(f, possibly_dirty=True)
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   736
        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
   737
47589
f5c24c124e07 dirstate: introduce an internal `_add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47558
diff changeset
   738
    def _add(self, filename):
f5c24c124e07 dirstate: introduce an internal `_add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47558
diff changeset
   739
        """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
   740
        self._addpath(filename, added=True)
f5c24c124e07 dirstate: introduce an internal `_add` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47558
diff changeset
   741
        self._map.copymap.pop(filename, None)
4616
70352337934e dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents: 4615
diff changeset
   742
47591
3d8b639bfbaa dirstate: introduce an internal `_drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47590
diff changeset
   743
    def _drop(self, filename):
3d8b639bfbaa dirstate: introduce an internal `_drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47590
diff changeset
   744
        """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
   745
        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
   746
            self._dirty = True
47591
3d8b639bfbaa dirstate: introduce an internal `_drop` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47590
diff changeset
   747
            self._updatedfiles.add(filename)
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   748
24538
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   749
    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
   750
        if exists is None:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   751
            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
   752
        if not exists:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   753
            # Maybe a path component exists
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   754
            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
   755
                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
   756
                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
   757
                folded = d + b"/" + f
24538
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   758
            else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   759
                # No path components, preserve original case
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   760
                folded = path
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   761
        else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   762
            # recursively normalize leading directory components
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   763
            # against dirstate
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   764
            if b'/' in normed:
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   765
                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
   766
                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
   767
                r = self._root + b"/" + d
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   768
                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
   769
            else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   770
                folded = util.fspath(normed, self._root)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   771
            storemap[normed] = folded
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   772
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   773
        return folded
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   774
24539
3a8eba78803e dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents: 24538
diff changeset
   775
    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
   776
        normed = util.normcase(path)
34676
bfddc3d678ae dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents: 34675
diff changeset
   777
        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
   778
        if folded is None:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   779
            if isknown:
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   780
                folded = path
7068
57377fa7eda2 issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents: 7034
diff changeset
   781
            else:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   782
                folded = self._discoverpath(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   783
                    path, normed, ignoremissing, exists, self._map.filefoldmap
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   784
                )
24539
3a8eba78803e dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents: 24538
diff changeset
   785
        return folded
16302
49b54f1ae053 dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents: 16258
diff changeset
   786
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   787
    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
   788
        normed = util.normcase(path)
34676
bfddc3d678ae dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents: 34675
diff changeset
   789
        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
   790
        if folded is None:
34678
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
   791
            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
   792
        if folded is None:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   793
            if isknown:
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   794
                folded = path
7068
57377fa7eda2 issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents: 7034
diff changeset
   795
            else:
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   796
                # 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
   797
                # normalizefile calls don't start matching directories
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   798
                folded = self._discoverpath(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   799
                    path, normed, ignoremissing, exists, self._map.dirfoldmap
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   800
                )
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   801
        return folded
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   802
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   803
    def normalize(self, path, isknown=False, ignoremissing=False):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
   804
        """
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   805
        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
   806
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   807
        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
   808
        disk, to avoid extra filesystem access.
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   809
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   810
        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
   811
        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
   812
        existing path components.
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   813
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   814
        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
   815
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   816
        - 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
   817
        - version of name stored on disk
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   818
        - version provided via command arguments
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
   819
        """
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   820
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   821
        if self._checkcase:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   822
            return self._normalize(path, isknown, ignoremissing)
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   823
        return path
6677
9865e15febd0 Add a normalize() method to dirstate
Paul Moore <p.f.moore@gmail.com>
parents: 6675
diff changeset
   824
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   825
    def clear(self):
34933
0217f75b6e59 dirstate: move clear onto dirstatemap class
Durham Goode <durham@fb.com>
parents: 34678
diff changeset
   826
        self._map.clear()
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
   827
        self._lastnormaltime = 0
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
   828
        self._updatedfiles.clear()
5123
79373ec3f27d merge with crew-stable
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5045 5065
diff changeset
   829
        self._dirty = True
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   830
18760
e74704c33e24 strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents: 18663
diff changeset
   831
    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
   832
        if changedfiles is None:
27176
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   833
            # Rebuild entire dirstate
43891
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   834
            to_lookup = allfiles
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   835
            to_drop = []
27176
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   836
            lastnormaltime = self._lastnormaltime
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   837
            self.clear()
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   838
            self._lastnormaltime = lastnormaltime
43891
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   839
        elif len(changedfiles) < 10:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   840
            # Avoid turning allfiles into a set, which can be expensive if it's
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   841
            # large.
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   842
            to_lookup = []
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   843
            to_drop = []
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   844
            for f in changedfiles:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   845
                if f in allfiles:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   846
                    to_lookup.append(f)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   847
                else:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   848
                    to_drop.append(f)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   849
        else:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   850
            changedfilesset = set(changedfiles)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   851
            to_lookup = changedfilesset & set(allfiles)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   852
            to_drop = changedfilesset - to_lookup
27176
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   853
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   854
        if self._origpl is None:
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   855
            self._origpl = self._pl
47012
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
   856
        self._map.setparents(parent, self._nodeconstants.nullid)
43891
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   857
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   858
        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
   859
            self._normallookup(f)
43891
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
   860
        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
   861
            self._drop(f)
30026
ba06562a06a2 dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents: 29889
diff changeset
   862
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
   863
        self._dirty = True
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   864
32750
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32682
diff changeset
   865
    def identity(self):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
   866
        """Return identity of dirstate itself to detect changing in storage
32750
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32682
diff changeset
   867
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32682
diff changeset
   868
        If identity of previous dirstate is equal to this, writing
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32682
diff changeset
   869
        changes based on the former dirstate out can keep consistency.
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
   870
        """
34675
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
   871
        return self._map.identity
32750
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32682
diff changeset
   872
29673
52ff07e1de91 deprecation: enforce thew 'tr' argument of 'dirstate.write' (API)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 29351
diff changeset
   873
    def write(self, tr):
4612
17ee7407097f dirstate: simplify dirty handling
Matt Mackall <mpm@selenic.com>
parents: 4611
diff changeset
   874
        if not self._dirty:
1794
98b6c1cad58b only write the dirstate when something changed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1755
diff changeset
   875
            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
   876
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   877
        filename = self._filename
29673
52ff07e1de91 deprecation: enforce thew 'tr' argument of 'dirstate.write' (API)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 29351
diff changeset
   878
        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
   879
            # '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
   880
            # 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
   881
            # 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
   882
            # 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
   883
            # 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
   884
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   885
            # 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
   886
            now = _getfsnow(self._opener)
35080
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
   887
            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
   888
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   889
            # 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
   890
            self._lastnormaltime = 0
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
   891
            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
   892
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   893
            # delay writing in-memory changes out
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   894
            tr.addfilegenerator(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   895
                b'dirstate',
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   896
                (self._filename,),
47674
ff97e793ed36 dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents: 47673
diff changeset
   897
                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
   898
                location=b'plain',
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   899
            )
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   900
            return
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   901
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   902
        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
   903
        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
   904
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   905
    def addparentchangecallback(self, category, callback):
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   906
        """add a callback to be called when the wd parents are changed
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   907
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   908
        Callback will be called with the following arguments:
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   909
            dirstate, (oldp1, oldp2), (newp1, newp2)
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   910
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   911
        Category is a unique identifier to allow overwriting an old callback
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   912
        with a newer callback.
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   913
        """
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   914
        self._plchangecallbacks[category] = callback
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   915
47674
ff97e793ed36 dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents: 47673
diff changeset
   916
    def _writedirstate(self, tr, st):
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   917
        # notify callbacks about parents change
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   918
        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
   919
            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
   920
                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
   921
            ):
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   922
                callback(self, self._origpl, self._pl)
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   923
            self._origpl = None
9509
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   924
        # 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
   925
        # filesystem's notion of 'now'
36781
ffa3026d4196 cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime
Augie Fackler <augie@google.com>
parents: 36622
diff changeset
   926
        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
   927
6c6b48aca328 dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents: 27176
diff changeset
   928
        # 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
   929
        # 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
   930
        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
   931
        if delaywrite > 0:
27398
c81675776c95 dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents: 27397
diff changeset
   932
            # do we have any files to delay for?
43425
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed
Yuya Nishihara <yuya@tcha.org>
parents: 43281
diff changeset
   933
            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
   934
                if e.need_delay(now):
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   935
                    import time  # to avoid useless import
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   936
27399
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
   937
                    # 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
   938
                    # 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
   939
                    clock = time.time()
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
   940
                    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
   941
                    end = start + delaywrite
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
   942
                    time.sleep(end - clock)
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   943
                    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
   944
                    break
27397
6c6b48aca328 dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents: 27176
diff changeset
   945
47674
ff97e793ed36 dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents: 47673
diff changeset
   946
        self._map.write(tr, st, now)
21026
7ee03e190c1d dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents: 20632
diff changeset
   947
        self._lastnormaltime = 0
34673
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
   948
        self._dirty = False
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   949
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   950
    def _dirignore(self, f):
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   951
        if self._ignore(f):
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   952
            return True
43633
0b7733719d21 utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents: 43620
diff changeset
   953
        for p in pathutil.finddirs(f):
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   954
            if self._ignore(p):
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   955
                return True
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   956
        return False
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   957
27594
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   958
    def _ignorefiles(self):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   959
        files = []
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   960
        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
   961
            files.append(self._join(b'.hgignore'))
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   962
        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
   963
            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
   964
                # 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
   965
                # 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
   966
                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
   967
        return files
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   968
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
   969
    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
   970
        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
   971
        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
   972
        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
   973
            i = files.popleft()
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   974
            patterns = matchmod.readpatternfile(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   975
                i, self._ui.warn, sourceinfo=True
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   976
            )
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
   977
            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
   978
                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
   979
                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
   980
                    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
   981
                        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
   982
                    continue
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   983
                m = matchmod.match(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   984
                    self._root, b'', [], [pattern], warn=self._ui.warn
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
   985
                )
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
   986
                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
   987
                    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
   988
            visited.add(i)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   989
        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
   990
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   991
    def _walkexplicit(self, match, subrepos):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
   992
        """Get stat data about the files explicitly specified by match.
3529
09d99b7e4da0 simplify dirstate walking
Matt Mackall <mpm@selenic.com>
parents: 3223
diff changeset
   993
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   994
        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
   995
        - 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
   996
          listings mapping subrepos and .hg to None.
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   997
        - 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
   998
        - dirsnotfound is a list of files that the dirstate thinks are
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
   999
          directories and that were not found."""
6578
f242d3684f83 walk: begin refactoring badmatch handling
Matt Mackall <mpm@selenic.com>
parents: 6577
diff changeset
  1000
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
  1001
        def badtype(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1002
            kind = _(b'unknown')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
  1003
            if stat.S_ISCHR(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1004
                kind = _(b'character device')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
  1005
            elif stat.S_ISBLK(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1006
                kind = _(b'block device')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
  1007
            elif stat.S_ISFIFO(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1008
                kind = _(b'fifo')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
  1009
            elif stat.S_ISSOCK(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1010
                kind = _(b'socket')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
  1011
            elif stat.S_ISDIR(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1012
                kind = _(b'directory')
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1013
            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
  1014
8676
acd69fc201a5 walk: we always have a badfn
Matt Mackall <mpm@selenic.com>
parents: 8675
diff changeset
  1015
        badfn = match.bad
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
  1016
        dmap = self._map
5000
46facb73ba8b dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents: 4965
diff changeset
  1017
        lstat = os.lstat
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
  1018
        getkind = stat.S_IFMT
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
  1019
        dirkind = stat.S_IFDIR
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
  1020
        regkind = stat.S_IFREG
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
  1021
        lnkkind = stat.S_IFLNK
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
  1022
        join = self._join
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
  1023
        dirsfound = []
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
  1024
        foundadd = dirsfound.append
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1025
        dirsnotfound = []
19175
63f7bd2e1a46 dirstate._walkexplicit: inline dirsnotfound.append
Siddharth Agarwal <sid0@fb.com>
parents: 19174
diff changeset
  1026
        notfoundadd = dirsnotfound.append
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
  1027
24448
55c449345b10 match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents: 24212
diff changeset
  1028
        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
  1029
            normalize = self._normalize
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
  1030
        else:
18032
a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents: 18018
diff changeset
  1031
            normalize = None
12907
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
  1032
12211
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
  1033
        files = sorted(match.files())
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
  1034
        subrepos.sort()
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
  1035
        i, j = 0, 0
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
  1036
        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
  1037
            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
  1038
            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
  1039
                i += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
  1040
                continue
13339
22167be007ed subrepo: fix pruning of subrepo filenames in dirstate (issue2619)
trbs <trbs@trbs.net>
parents: 13233
diff changeset
  1041
            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
  1042
                del files[i]
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
  1043
            j += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
  1044
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1045
        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
  1046
            files = [b'']
42340
7ada598941d2 dirstate: move special handling of files==['.'] together
Martin von Zweigbergk <martinvonz@google.com>
parents: 42304
diff changeset
  1047
            # constructing the foldmap is expensive, so don't do it for the
42341
27d6956d386b match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents: 42340
diff changeset
  1048
            # common case where files is ['']
42340
7ada598941d2 dirstate: move special handling of files==['.'] together
Martin von Zweigbergk <martinvonz@google.com>
parents: 42304
diff changeset
  1049
            normalize = None
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
  1050
        results = dict.fromkeys(subrepos)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1051
        results[b'.hg'] = None
5000
46facb73ba8b dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents: 4965
diff changeset
  1052
12211
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
  1053
        for ff in files:
42340
7ada598941d2 dirstate: move special handling of files==['.'] together
Martin von Zweigbergk <martinvonz@google.com>
parents: 42304
diff changeset
  1054
            if normalize:
24522
18085e46caa9 dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents: 24521
diff changeset
  1055
                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
  1056
            else:
24522
18085e46caa9 dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents: 24521
diff changeset
  1057
                nf = ff
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
  1058
            if nf in results:
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
  1059
                continue
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
  1060
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
  1061
            try:
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
  1062
                st = lstat(join(nf))
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
  1063
                kind = getkind(st.st_mode)
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
  1064
                if kind == dirkind:
8588
2624f485b9bc dirstate: set more states in step 1 of walk
Simon Heimberg <simohe@besonet.ch>
parents: 8521
diff changeset
  1065
                    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
  1066
                        # 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
  1067
                        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
  1068
                    foundadd((nf, ff))
12401
4cdaf1adafc8 backout most of 4f8067c94729
Matt Mackall <mpm@selenic.com>
parents: 12387
diff changeset
  1069
                elif kind == regkind or kind == lnkkind:
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
  1070
                    results[nf] = st
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
  1071
                else:
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
  1072
                    badfn(ff, badtype(kind))
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
  1073
                    if nf in dmap:
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
  1074
                        results[nf] = None
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1075
            except OSError as inst:  # nf not found on disk - it is dirstate only
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1076
                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
  1077
                    results[nf] = None
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1078
                else:  # does it match a missing directory?
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1079
                    if self._map.hasdir(nf):
23375
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
  1080
                        notfoundadd(nf)
8677
34df078b8b1b walk: simplify logic for badfn clause
Matt Mackall <mpm@selenic.com>
parents: 8676
diff changeset
  1081
                    else:
34022
d5b2beca16c0 python3: wrap all uses of <exception>.strerror with strtolocal
Augie Fackler <raf@durin42.com>
parents: 33981
diff changeset
  1082
                        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
  1083
36200
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
  1084
        # match.files() may contain explicitly-specified paths that shouldn't
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
  1085
        # be taken; drop them from the list of files found. dirsfound/notfound
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
  1086
        # aren't filtered here because they will be tested later.
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
  1087
        if match.anypats():
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
  1088
            for f in list(results):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1089
                if f == b'.hg' or f in subrepos:
36200
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
  1090
                    # keep sentinel to disable further out-of-repo walks
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
  1091
                    continue
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
  1092
                if not match(f):
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
  1093
                    del results[f]
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
  1094
25877
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
  1095
        # 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
  1096
        # 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
  1097
        # 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
  1098
        # 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
  1099
        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
  1100
            normed = {}
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
  1101
43106
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents: 43090
diff changeset
  1102
            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
  1103
                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
  1104
                    continue
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
  1105
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
  1106
                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
  1107
                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
  1108
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
  1109
                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
  1110
                    paths = set()
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
  1111
                    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
  1112
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
  1113
                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
  1114
43106
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents: 43090
diff changeset
  1115
            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
  1116
                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
  1117
                    for path in paths:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1118
                        folded = self._discoverpath(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1119
                            path, norm, True, None, self._map.dirfoldmap
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1120
                        )
25877
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
  1121
                        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
  1122
                            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
  1123
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
  1124
        return results, dirsfound, dirsnotfound
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1125
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
  1126
    def walk(self, match, subrepos, unknown, ignored, full=True):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
  1127
        """
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1128
        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
  1129
        matched by match.
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1130
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
  1131
        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
  1132
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1133
        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
  1134
        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
  1135
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
  1136
        """
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
  1137
        # 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
  1138
        # 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
  1139
        # 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
  1140
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1141
        if ignored:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1142
            ignore = util.never
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1143
            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
  1144
        elif unknown:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
  1145
            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
  1146
            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
  1147
        else:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
  1148
            # 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
  1149
            ignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1150
            dirignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1151
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1152
        matchfn = match.matchfn
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1153
        matchalways = match.always()
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1154
        matchtdir = match.traversedir
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1155
        dmap = self._map
32208
d74b0cff94a9 osutil: proxy through util (and platform) modules (API)
Yuya Nishihara <yuya@tcha.org>
parents: 32177
diff changeset
  1156
        listdir = util.listdir
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1157
        lstat = os.lstat
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1158
        dirkind = stat.S_IFDIR
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1159
        regkind = stat.S_IFREG
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1160
        lnkkind = stat.S_IFLNK
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1161
        join = self._join
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1162
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1163
        exact = skipstep3 = False
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1164
        if match.isexact():  # match.exact
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1165
            exact = True
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1166
            dirignore = util.always  # skip step 2
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1167
        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
  1168
            skipstep3 = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1169
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1170
        if not exact and self._checkcase:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1171
            normalize = self._normalize
24541
e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents: 24540
diff changeset
  1172
            normalizefile = self._normalizefile
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1173
            skipstep3 = False
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1174
        else:
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1175
            normalize = self._normalize
24541
e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents: 24540
diff changeset
  1176
            normalizefile = None
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1177
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1178
        # step 1: find all explicit files
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1179
        results, work, dirsnotfound = self._walkexplicit(match, subrepos)
43713
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents: 43696
diff changeset
  1180
        if matchtdir:
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents: 43696
diff changeset
  1181
            for d in work:
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents: 43696
diff changeset
  1182
                matchtdir(d[0])
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents: 43696
diff changeset
  1183
            for d in dirsnotfound:
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents: 43696
diff changeset
  1184
                matchtdir(d)
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
  1185
19172
c6cea2e2031b dirstate.walk: pull skipstep3 out of the explicit walk code
Siddharth Agarwal <sid0@fb.com>
parents: 19171
diff changeset
  1186
        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
  1187
        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
  1188
6826
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents: 6825
diff changeset
  1189
        # 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
  1190
        def traverse(work, alreadynormed):
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1191
            wadd = work.append
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1192
            while work:
43239
6fcdcea2b03a dirstate: add some traces on listdir calls
Augie Fackler <augie@google.com>
parents: 43117
diff changeset
  1193
                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
  1194
                nd = work.pop()
38956
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
  1195
                visitentries = match.visitchildrenset(nd)
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
  1196
                if not visitentries:
32177
8f1a2b848b52 dirstate: optimize walk() by using match.visitdir()
Martin von Zweigbergk <martinvonz@google.com>
parents: 31547
diff changeset
  1197
                    continue
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1198
                if visitentries == b'this' or visitentries == b'all':
38956
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
  1199
                    visitentries = None
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1200
                skip = None
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1201
                if nd != b'':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1202
                    skip = b'.hg'
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1203
                try:
43239
6fcdcea2b03a dirstate: add some traces on listdir calls
Augie Fackler <augie@google.com>
parents: 43117
diff changeset
  1204
                    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
  1205
                        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
  1206
                except OSError as inst:
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1207
                    if inst.errno in (errno.EACCES, errno.ENOENT):
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1208
                        match.bad(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1209
                            self.pathto(nd), encoding.strtolocal(inst.strerror)
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1210
                        )
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1211
                        continue
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1212
                    raise
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1213
                for f, kind, st in entries:
39260
27946fca8a05 match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents: 38959
diff changeset
  1214
                    # Some matchers may return files in the visitentries set,
27946fca8a05 match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents: 38959
diff changeset
  1215
                    # instead of 'this', if the matcher explicitly mentions them
27946fca8a05 match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents: 38959
diff changeset
  1216
                    # and is not an exactmatcher. This is acceptable; we do not
27946fca8a05 match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents: 38959
diff changeset
  1217
                    # make any hard assumptions about file-or-directory below
27946fca8a05 match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents: 38959
diff changeset
  1218
                    # based on the presence of `f` in visitentries. If
27946fca8a05 match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents: 38959
diff changeset
  1219
                    # visitchildrenset returned a set, we can always skip the
27946fca8a05 match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents: 38959
diff changeset
  1220
                    # entries *not* in the set it provided regardless of whether
27946fca8a05 match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents: 38959
diff changeset
  1221
                    # they're actually a file or a directory.
38956
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
  1222
                    if visitentries and f not in visitentries:
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
  1223
                        continue
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1224
                    if normalizefile:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1225
                        # 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
  1226
                        # 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
  1227
                        # dmap -- therefore normalizefile is enough
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1228
                        nf = normalizefile(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1229
                            nd and (nd + b"/" + f) or f, True, True
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1230
                        )
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1231
                    else:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1232
                        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
  1233
                    if nf not in results:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1234
                        if kind == dirkind:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1235
                            if not ignore(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1236
                                if matchtdir:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1237
                                    matchtdir(nf)
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1238
                                wadd(nf)
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1239
                            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
  1240
                                results[nf] = None
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1241
                        elif kind == regkind or kind == lnkkind:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1242
                            if nf in dmap:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1243
                                if matchalways or matchfn(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1244
                                    results[nf] = st
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1245
                            elif (matchalways or matchfn(nf)) and not ignore(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1246
                                nf
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1247
                            ):
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1248
                                # 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
  1249
                                if not alreadynormed:
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1250
                                    nf = normalize(nf, False, True)
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1251
                                results[nf] = st
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1252
                        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
  1253
                            results[nf] = None
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1254
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1255
        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
  1256
            # 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
  1257
            # expensive directory normalization
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1258
            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
  1259
            traverse([d], alreadynormed)
536
c15b4bc0a11c Refactor diffrevs/diffdir into changes
mpm@selenic.com
parents: 529
diff changeset
  1260
18812
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18792
diff changeset
  1261
        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
  1262
            del results[s]
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1263
        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
  1264
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
  1265
        # 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
  1266
        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
  1267
            # 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
  1268
            # 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
  1269
            # 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
  1270
            if not results and matchalways:
31422
2e38a88bbc6c dirstate: use list comprehension to get a list of keys
Pulkit Goyal <7895pulkit@gmail.com>
parents: 31278
diff changeset
  1271
                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
  1272
            else:
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
  1273
                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
  1274
            visit.sort()
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
  1275
18625
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1276
            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
  1277
                # 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
  1278
                # 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
  1279
                # 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
  1280
                # The rest must thus be ignored or under a symlink.
33649
377e8ddaebef pathauditor: disable cache of audited paths by default (issue5628)
Yuya Nishihara <yuya@tcha.org>
parents: 33440
diff changeset
  1281
                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
  1282
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1283
                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
  1284
                    # 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
  1285
                    # 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
  1286
                    # 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
  1287
                    # on disk.
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1288
                    if (
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1289
                        normalizefile
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1290
                        and normalizefile(nf, True, True) in results
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1291
                    ):
24621
1784ca148392 dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents: 24537
diff changeset
  1292
                        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
  1293
                    # 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
  1294
                    # 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
  1295
                    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
  1296
                        try:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
  1297
                            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
  1298
                            # 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
  1299
                        except OSError:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
  1300
                            # file doesn't exist
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
  1301
                            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
  1302
                    else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1303
                        # 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
  1304
                        # 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
  1305
                        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
  1306
            else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1307
                # 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
  1308
                # so stat and check everything we missed.
31507
4d1dd9cf0dca dirstate: use future-proof next(iter) instead of iter.next
Augie Fackler <augie@google.com>
parents: 31422
diff changeset
  1309
                iv = iter(visit)
26984
af2663680e95 dirstate: back out 502b56a9e897
Bryan O'Sullivan <bos@serpentine.com>
parents: 26887
diff changeset
  1310
                for st in util.statfiles([join(i) for i in visit]):
31507
4d1dd9cf0dca dirstate: use future-proof next(iter) instead of iter.next
Augie Fackler <augie@google.com>
parents: 31422
diff changeset
  1311
                    results[next(iv)] = st
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
  1312
        return results
669
8aa2a282eda4 .hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents: 667
diff changeset
  1313
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1314
    def _rust_status(self, matcher, list_clean, list_ignored, list_unknown):
44078
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1315
        # Force Rayon (Rust parallelism library) to respect the number of
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1316
        # workers. This is a temporary workaround until Rust code knows
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1317
        # how to read the config file.
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1318
        numcpus = self._ui.configint(b"worker", b"numcpus")
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1319
        if numcpus is not None:
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1320
            encoding.environ.setdefault(b'RAYON_NUM_THREADS', b'%d' % numcpus)
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1321
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1322
        workers_enabled = self._ui.configbool(b"worker", b"enabled", True)
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1323
        if not workers_enabled:
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1324
            encoding.environ[b"RAYON_NUM_THREADS"] = b"1"
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1325
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1326
        (
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1327
            lookup,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1328
            modified,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1329
            added,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1330
            removed,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1331
            deleted,
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1332
            clean,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1333
            ignored,
44078
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1334
            unknown,
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1335
            warnings,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1336
            bad,
44840
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents: 44836
diff changeset
  1337
            traversed,
47350
04d1f17f49e7 dirstate-v2: Write .hg/dirstate back to disk on directory cache changes
Simon Sapin <simon.sapin@octobus.net>
parents: 47320
diff changeset
  1338
            dirty,
44078
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1339
        ) = rustmod.status(
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1340
            self._map._rustmap,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1341
            matcher,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1342
            self._rootdir,
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1343
            self._ignorefiles(),
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1344
            self._checkexec,
44078
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1345
            self._lastnormaltime,
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1346
            bool(list_clean),
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1347
            bool(list_ignored),
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1348
            bool(list_unknown),
44840
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents: 44836
diff changeset
  1349
            bool(matcher.traversedir),
44078
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1350
        )
44840
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents: 44836
diff changeset
  1351
47350
04d1f17f49e7 dirstate-v2: Write .hg/dirstate back to disk on directory cache changes
Simon Sapin <simon.sapin@octobus.net>
parents: 47320
diff changeset
  1352
        self._dirty |= dirty
04d1f17f49e7 dirstate-v2: Write .hg/dirstate back to disk on directory cache changes
Simon Sapin <simon.sapin@octobus.net>
parents: 47320
diff changeset
  1353
44840
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents: 44836
diff changeset
  1354
        if matcher.traversedir:
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents: 44836
diff changeset
  1355
            for dir in traversed:
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents: 44836
diff changeset
  1356
                matcher.traversedir(dir)
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents: 44836
diff changeset
  1357
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1358
        if self._ui.warn:
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1359
            for item in warnings:
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1360
                if isinstance(item, tuple):
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1361
                    file_path, syntax = item
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1362
                    msg = _(b"%s: ignoring invalid syntax '%s'\n") % (
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1363
                        file_path,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1364
                        syntax,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1365
                    )
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1366
                    self._ui.warn(msg)
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1367
                else:
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1368
                    msg = _(b"skipping unreadable pattern file '%s': %s\n")
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1369
                    self._ui.warn(
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1370
                        msg
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1371
                        % (
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1372
                            pathutil.canonpath(
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1373
                                self._rootdir, self._rootdir, item
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1374
                            ),
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1375
                            b"No such file or directory",
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1376
                        )
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1377
                    )
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1378
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1379
        for (fn, message) in bad:
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1380
            matcher.bad(fn, encoding.strtolocal(message))
44078
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1381
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1382
        status = scmutil.status(
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1383
            modified=modified,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1384
            added=added,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1385
            removed=removed,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1386
            deleted=deleted,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1387
            unknown=unknown,
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1388
            ignored=ignored,
44078
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1389
            clean=clean,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1390
        )
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1391
        return (lookup, status)
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
  1392
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
  1393
    def status(self, match, subrepos, ignored, clean, unknown):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
  1394
        """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
  1395
        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
  1396
        scmutil.status and:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1397
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1398
          unsure:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1399
            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
  1400
            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
  1401
            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
  1402
          status.modified:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1403
            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
  1404
            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
  1405
          status.clean:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1406
            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
  1407
            dirstate was written
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
  1408
        """
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
  1409
        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
  1410
        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
  1411
        removed, deleted, clean = [], [], []
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
  1412
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1413
        dmap = self._map
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1414
        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
  1415
733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents: 43239
diff changeset
  1416
        use_rust = True
43917
40fd1ef4e4c1 rust-matchers: add support for `exactmatcher` in `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents: 43891
diff changeset
  1417
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1418
        allowed_matchers = (
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1419
            matchmod.alwaysmatcher,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1420
            matchmod.exactmatcher,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1421
            matchmod.includematcher,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1422
        )
43917
40fd1ef4e4c1 rust-matchers: add support for `exactmatcher` in `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents: 43891
diff changeset
  1423
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
  1424
        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
  1425
            use_rust = False
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1426
        elif self._checkcase:
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1427
            # Case-insensitive filesystems are not handled yet
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1428
            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
  1429
        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
  1430
            use_rust = False
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1431
        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
  1432
            use_rust = False
43917
40fd1ef4e4c1 rust-matchers: add support for `exactmatcher` in `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents: 43891
diff changeset
  1433
        elif not isinstance(match, allowed_matchers):
44836
63edfea7dfde status: update comment to reflect the more recent situation
Raphaël Gomès <rgomes@octobus.net>
parents: 44801
diff changeset
  1434
            # 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
  1435
            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
  1436
733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents: 43239
diff changeset
  1437
        if use_rust:
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1438
            try:
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1439
                return self._rust_status(
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1440
                    match, listclean, listignored, listunknown
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1441
                )
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1442
            except rustmod.FallbackError:
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1443
                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
  1444
43620
dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents: 43612
diff changeset
  1445
        def noop(f):
dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents: 43612
diff changeset
  1446
            pass
dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents: 43612
diff changeset
  1447
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1448
        dcontains = dmap.__contains__
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1449
        dget = dmap.__getitem__
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1450
        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
  1451
        madd = modified.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1452
        aadd = added.append
43620
dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents: 43612
diff changeset
  1453
        uadd = unknown.append if listunknown else noop
dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents: 43612
diff changeset
  1454
        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
  1455
        radd = removed.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1456
        dadd = deleted.append
43620
dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents: 43612
diff changeset
  1457
        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
  1458
        mexact = match.exact
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1459
        dirignore = self._dirignore
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1460
        checkexec = self._checkexec
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
  1461
        copymap = self._map.copymap
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1462
        lastnormaltime = self._lastnormaltime
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1463
19191
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
  1464
        # 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
  1465
        # - we're listing all clean files, or
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
  1466
        # - 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
  1467
        #   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
  1468
        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
  1469
        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
  1470
            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
  1471
        ):
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1472
            if not dcontains(fn):
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1473
                if (listignored or mexact(fn)) and dirignore(fn):
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
  1474
                    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
  1475
                        iadd(fn)
19910
601944f41257 dirstate.status: return explicit unknown files even when not asked
Siddharth Agarwal <sid0@fb.com>
parents: 19651
diff changeset
  1476
                else:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1477
                    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
  1478
                continue
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
  1479
21810
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1480
            # 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
  1481
            # 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
  1482
            # 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
  1483
            # 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
  1484
            # 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
  1485
            # 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
  1486
            # 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
  1487
            t = dget(fn)
47536
8e4b9fe31334 dirstate-entry: add a `mode` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47535
diff changeset
  1488
            mode = t.mode
47537
0e5800c88eb4 dirstate-entry: add a `size` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47536
diff changeset
  1489
            size = t.size
47538
77fce401a2bb dirstate-entry: add a `mtime` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47537
diff changeset
  1490
            time = t.mtime
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
  1491
47531
f5b8f0b9c129 dirstate-entry: add a `tracked` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47530
diff changeset
  1492
            if not st and t.tracked:
6818
6e93fbd847ef dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents: 6811
diff changeset
  1493
                dadd(fn)
47533
174d0bcce2eb dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47532
diff changeset
  1494
            elif t.merged:
174d0bcce2eb dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47532
diff changeset
  1495
                madd(fn)
174d0bcce2eb dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47532
diff changeset
  1496
            elif t.added:
174d0bcce2eb dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47532
diff changeset
  1497
                aadd(fn)
174d0bcce2eb dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47532
diff changeset
  1498
            elif t.removed:
174d0bcce2eb dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47532
diff changeset
  1499
                radd(fn)
47534
e53a42dce923 dirstate: drop last explicite `state` usage in status
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47533
diff changeset
  1500
            elif t.tracked:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1501
                if (
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1502
                    size >= 0
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1503
                    and (
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1504
                        (size != st.st_size and size != st.st_size & _rangemask)
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1505
                        or ((mode ^ st.st_mode) & 0o100 and checkexec)
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1506
                    )
47514
559aee84b889 dirstate-entry: add a `from_p2` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 47513
diff changeset
  1507
                    or t.from_p2
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1508
                    or fn in copymap
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1509
                ):
46703
ca69e29a2a30 formatting: fix redundant parentheses
Raphaël Gomès <rgomes@octobus.net>
parents: 46678
diff changeset
  1510
                    if stat.S_ISLNK(st.st_mode) and size != st.st_size:
46678
0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt
Corey Schuhen <cschuhen@topcon.com>
parents: 45942
diff changeset
  1511
                        # issue6456: Size returned may be longer due to
0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt
Corey Schuhen <cschuhen@topcon.com>
parents: 45942
diff changeset
  1512
                        # encryption on EXT-4 fscrypt, undecided.
0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt
Corey Schuhen <cschuhen@topcon.com>
parents: 45942
diff changeset
  1513
                        ladd(fn)
0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt
Corey Schuhen <cschuhen@topcon.com>
parents: 45942
diff changeset
  1514
                    else:
0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt
Corey Schuhen <cschuhen@topcon.com>
parents: 45942
diff changeset
  1515
                        madd(fn)
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1516
                elif (
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1517
                    time != st[stat.ST_MTIME]
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1518
                    and time != st[stat.ST_MTIME] & _rangemask
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1519
                ):
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1520
                    ladd(fn)
36781
ffa3026d4196 cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime
Augie Fackler <augie@google.com>
parents: 36622
diff changeset
  1521
                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
  1522
                    # 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
  1523
                    # 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
  1524
                    # This can happen if we quickly do multiple commits.
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
  1525
                    # 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
  1526
                    ladd(fn)
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
  1527
                elif listclean:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1528
                    cadd(fn)
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1529
        status = scmutil.status(
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1530
            modified, added, removed, deleted, unknown, ignored, clean
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1531
        )
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
  1532
        return (lookup, status)
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1533
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1534
    def matches(self, match):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
  1535
        """
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1536
        return files in the dirstate (in whatever state) filtered by match
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
  1537
        """
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1538
        dmap = self._map
44357
bed8d08cfcb2 rust-dirstatemap: remove additional lookup in dirstate.matches
Raphaël Gomès <rgomes@octobus.net>
parents: 44297
diff changeset
  1539
        if rustmod is not None:
bed8d08cfcb2 rust-dirstatemap: remove additional lookup in dirstate.matches
Raphaël Gomès <rgomes@octobus.net>
parents: 44297
diff changeset
  1540
            dmap = self._map._rustmap
bed8d08cfcb2 rust-dirstatemap: remove additional lookup in dirstate.matches
Raphaël Gomès <rgomes@octobus.net>
parents: 44297
diff changeset
  1541
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1542
        if match.always():
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1543
            return dmap.keys()
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1544
        files = match.files()
24448
55c449345b10 match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents: 24212
diff changeset
  1545
        if match.isexact():
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1546
            # 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
  1547
            # much smaller than dmap
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1548
            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
  1549
        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
  1550
            # 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
  1551
            # that
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1552
            return list(files)
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1553
        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
  1554
26746
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
  1555
    def _actualfilename(self, tr):
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
  1556
        if tr:
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1557
            return self._pendingfilename
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1558
        else:
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1559
            return self._filename
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1560
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1561
    def savebackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1562
        '''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
  1563
        filename = self._actualfilename(tr)
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1564
        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
  1565
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1566
        # 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
  1567
        # 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
  1568
        # output file will be used to create backup of dirstate at this point.
31208
fc57a8b95f1b dirstate: avoid unnecessary load+dump during backup
Jun Wu <quark@fb.com>
parents: 31207
diff changeset
  1569
        if self._dirty or not self._opener.exists(filename):
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1570
            self._writedirstate(
47674
ff97e793ed36 dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents: 47673
diff changeset
  1571
                tr,
ff97e793ed36 dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents: 47673
diff changeset
  1572
                self._opener(filename, b"w", atomictemp=True, checkambig=True),
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1573
            )
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1574
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1575
        if tr:
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1576
            # 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
  1577
            # 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
  1578
            # changed after this
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1579
            tr.addfilegenerator(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1580
                b'dirstate',
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1581
                (self._filename,),
47674
ff97e793ed36 dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents: 47673
diff changeset
  1582
                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
  1583
                location=b'plain',
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1584
            )
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1585
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1586
            # 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
  1587
            # 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
  1588
            # end of this transaction
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
  1589
            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
  1590
31547
ddadb6b0b58e dirstate: use tryunlink
Ryan McElroy <rmcelroy@fb.com>
parents: 31507
diff changeset
  1591
        self._opener.tryunlink(backupname)
31207
1ef37b16b8e8 dirstate: try to use hardlink to backup dirstate
Jun Wu <quark@fb.com>
parents: 31206
diff changeset
  1592
        # hardlink backup is okay because _writedirstate is always called
1ef37b16b8e8 dirstate: try to use hardlink to backup dirstate
Jun Wu <quark@fb.com>
parents: 31206
diff changeset
  1593
        # with an "atomictemp=True" file.
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1594
        util.copyfile(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1595
            self._opener.join(filename),
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1596
            self._opener.join(backupname),
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1597
            hardlink=True,
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
  1598
        )
26632
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26630
diff changeset
  1599
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1600
    def restorebackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1601
        '''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
  1602
        # 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
  1603
        # 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
  1604
        self.invalidate()
26746
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
  1605
        filename = self._actualfilename(tr)
34940
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
  1606
        o = self._opener
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
  1607
        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
  1608
            o.unlink(backupname)
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
  1609
        else:
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
  1610
            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
  1611
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1612
    def clearbackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1613
        '''Clear backup file'''
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1614
        self._opener.unlink(backupname)