mercurial/dirstate.py
author Pulkit Goyal <pulkit@yandex-team.ru>
Tue, 19 Mar 2019 16:20:02 +0300
changeset 42006 111de135fc76
parent 41951 42dd69985778
child 42304 9c6c0f736e1d
permissions -rw-r--r--
branchcache: add attributes to track which nodes are verified Half of the cost of loading branchcache comes from verifiying all the nodes it has. We don't need to verify all the nodes in all the cases. Sometimes we need to verify only a set of nodes for a set of branches. We can ignore nodes of other branches as we are not going to read them. This patch introduces two attributes to branchcache class. _verifiedbranches is a set which will tell the branches for which it's head nodes are verified. _closedverified is a boolean which will tell whether all closednodes are verified or not. Another idea which I had was to keep a set of nodes which are verified, but it will be more ugly and difficult to track things on node level. Differential Revision: https://phab.mercurial-scm.org/D6156
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
#
8b2cd04a6e97 put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents: 8225
diff changeset
     3
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
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 _
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    17
from .node import nullid
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    18
from . import (
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    19
    encoding,
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    20
    error,
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    21
    match as matchmod,
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    22
    pathutil,
32372
df448de7cf3b parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents: 32352
diff changeset
    23
    policy,
30304
ba2c04059317 py3: use pycompat.ossep at certain places
Pulkit Goyal <7895pulkit@gmail.com>
parents: 30224
diff changeset
    24
    pycompat,
27503
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    25
    scmutil,
31050
206532700213 txnutil: factor out the logic to read file in according to HG_PENDING
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 30634
diff changeset
    26
    txnutil,
27503
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    27
    util,
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    28
)
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
    29
32372
df448de7cf3b parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents: 32352
diff changeset
    30
parsers = policy.importmod(r'parsers')
df448de7cf3b parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents: 32352
diff changeset
    31
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    32
propertycache = util.propertycache
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    33
filecache = scmutil.filecache
17733
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents: 17197
diff changeset
    34
_rangemask = 0x7fffffff
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    35
21809
e250b8300e6e parsers: inline fields of dirstate values in C version
Siddharth Agarwal <sid0@fb.com>
parents: 21808
diff changeset
    36
dirstatetuple = parsers.dirstatetuple
21808
7537e57f5dbd dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents: 21116
diff changeset
    37
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    38
class repocache(filecache):
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    39
    """filecache for files in .hg/"""
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    40
    def join(self, obj, fname):
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    41
        return obj._opener.join(fname)
4610
274c99fc629f dirstate: simplify state()
Matt Mackall <mpm@selenic.com>
parents: 4609
diff changeset
    42
16202
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    43
class rootcache(filecache):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    44
    """filecache for files in the repository root"""
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    45
    def join(self, obj, fname):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    46
        return obj._join(fname)
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    47
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
    48
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
    49
    '''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
    50
    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
    51
    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
    52
        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
    53
    finally:
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
    54
        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
    55
        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
    56
1559
59b3639df0a9 Convert all classes to new-style classes by deriving them from object.
Eric Hopper <hopper@omnifarious.org>
parents: 1541
diff changeset
    57
class dirstate(object):
2393
5083cba2a777 dirstate: refactor the dirstate binary format, remove magic numbers
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 2063
diff changeset
    58
33373
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
    59
    def __init__(self, opener, ui, root, validate, sparsematchfn):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    60
        '''Create a new dirstate object.
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    61
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    62
        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
    63
        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
    64
        the dirstate.
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    65
        '''
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
    66
        self._opener = opener
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 12907
diff changeset
    67
        self._validate = validate
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
    68
        self._root = root
33373
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
    69
        self._sparsematchfn = sparsematchfn
24198
3cc630be5f09 dirstate: make sure rootdir ends with directory separator (issue4557)
Yuya Nishihara <yuya@tcha.org>
parents: 23866
diff changeset
    70
        # 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
    71
        # 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
    72
        self._rootdir = pathutil.normasprefix(root)
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
    73
        self._dirty = False
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
    74
        self._lastnormaltime = 0
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
    75
        self._ui = ui
16200
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16143
diff changeset
    76
        self._filecache = {}
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    77
        self._parentwriters = 0
25226
00d426a38137 dirstate: use self._filename instead of immediate string `dirstate`
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 25216
diff changeset
    78
        self._filename = 'dirstate'
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
    79
        self._pendingfilename = '%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
    80
        self._plchangecallbacks = {}
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
    81
        self._origpl = None
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
    82
        self._updatedfiles = set()
35086
8db4ca768416 dirstate: make map implementation overridable
Mark Thomas <mbthomas@fb.com>
parents: 35084
diff changeset
    83
        self._mapcls = dirstatemap
41674
e178b131906a dirstate: call and cache os.getcwd() in constructor
Martin von Zweigbergk <martinvonz@google.com>
parents: 40424
diff changeset
    84
        # 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
    85
        # 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
    86
        # raises an exception).
e178b131906a dirstate: call and cache os.getcwd() in constructor
Martin von Zweigbergk <martinvonz@google.com>
parents: 40424
diff changeset
    87
        self._cwd
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    88
32346
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
    89
    @contextlib.contextmanager
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
    90
    def parentchange(self):
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
    91
        '''Context manager for handling dirstate parents.
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
    92
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
    93
        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
    94
        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
    95
        released.
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
    96
        '''
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
    97
        self._parentwriters += 1
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
    98
        yield
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
    99
        # 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
   100
        # 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
   101
        # 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
   102
        # 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
   103
        # 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
   104
        self._parentwriters -= 1
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
   105
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   106
    def pendingparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   107
        '''Returns true if the dirstate is in the middle of a set of changes
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   108
        that modify the dirstate parent.
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   109
        '''
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   110
        return self._parentwriters > 0
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
   111
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   112
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   113
    def _map(self):
35078
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
   114
        """Return the dirstate contents (see documentation for dirstatemap)."""
35086
8db4ca768416 dirstate: make map implementation overridable
Mark Thomas <mbthomas@fb.com>
parents: 35084
diff changeset
   115
        self._map = self._mapcls(self._ui, self._opener, self._root)
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   116
        return self._map
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   117
33373
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
   118
    @property
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
   119
    def _sparsematcher(self):
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
   120
        """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
   121
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
   122
        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
   123
        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
   124
        included in the working directory.
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
   125
        """
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
   126
        # 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
   127
        # 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
   128
        # 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
   129
        return self._sparsematchfn()
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
   130
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
   131
    @repocache('branch')
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   132
    def _branch(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   133
        try:
14168
135e244776f0 prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 13974
diff changeset
   134
            return self._opener.read("branch").strip() or "default"
25660
328739ea70c3 global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25658
diff changeset
   135
        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
   136
            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
   137
                raise
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   138
            return "default"
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   139
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
   140
    @property
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   141
    def _pl(self):
34338
0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class
Durham Goode <durham@fb.com>
parents: 34337
diff changeset
   142
        return self._map.parents()
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   143
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
   144
    def hasdir(self, d):
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
   145
        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
   146
16202
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
   147
    @rootcache('.hgignore')
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   148
    def _ignore(self):
27594
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   149
        files = self._ignorefiles()
25216
dc562165044a ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents: 25163
diff changeset
   150
        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
   151
            return matchmod.never()
25216
dc562165044a ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents: 25163
diff changeset
   152
dc562165044a ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents: 25163
diff changeset
   153
        pats = ['include:%s' % f for f in files]
dc562165044a ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents: 25163
diff changeset
   154
        return matchmod.match(self._root, '', [], pats, warn=self._ui.warn)
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   155
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   156
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   157
    def _slash(self):
30304
ba2c04059317 py3: use pycompat.ossep at certain places
Pulkit Goyal <7895pulkit@gmail.com>
parents: 30224
diff changeset
   158
        return self._ui.configbool('ui', 'slash') and pycompat.ossep != '/'
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   159
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   160
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   161
    def _checklink(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   162
        return util.checklink(self._root)
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   163
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   164
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   165
    def _checkexec(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   166
        return util.checkexec(self._root)
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   167
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   168
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   169
    def _checkcase(self):
29889
6f447b9ec263 util: rename checkcase() to fscasesensitive() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents: 29772
diff changeset
   170
        return not util.fscasesensitive(self._join('.hg'))
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   171
4905
fc61495ea9cf dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents: 4904
diff changeset
   172
    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
   173
        # 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
   174
        # 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
   175
        return self._rootdir + f
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
   176
15337
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   177
    def flagfunc(self, buildfallback):
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   178
        if self._checklink and self._checkexec:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   179
            def f(x):
18869
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   180
                try:
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   181
                    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
   182
                    if util.statislink(st):
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   183
                        return 'l'
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   184
                    if util.statisexec(st):
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   185
                        return 'x'
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   186
                except OSError:
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   187
                    pass
15337
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   188
                return ''
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   189
            return f
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   190
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   191
        fallback = buildfallback()
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   192
        if self._checklink:
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   193
            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
   194
                if os.path.islink(self._join(x)):
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   195
                    return 'l'
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   196
                if 'x' in fallback(x):
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   197
                    return 'x'
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   198
                return ''
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   199
            return f
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   200
        if self._checkexec:
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   201
            def f(x):
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   202
                if 'l' in fallback(x):
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   203
                    return 'l'
14273
38af0f514134 rename util.is_exec to isexec
Adrian Buehlmann <adrian@cadifra.com>
parents: 14168
diff changeset
   204
                if util.isexec(self._join(x)):
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   205
                    return 'x'
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   206
                return ''
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   207
            return f
15337
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   208
        else:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   209
            return fallback
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   210
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
   211
    @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
   212
    def _cwd(self):
33215
b7f6885cb055 dirstate: centralize _cwd handling into _cwd method
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32772
diff changeset
   213
        # internal config: ui.forcecwd
b7f6885cb055 dirstate: centralize _cwd handling into _cwd method
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32772
diff changeset
   214
        forcecwd = self._ui.config('ui', 'forcecwd')
b7f6885cb055 dirstate: centralize _cwd handling into _cwd method
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32772
diff changeset
   215
        if forcecwd:
b7f6885cb055 dirstate: centralize _cwd handling into _cwd method
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32772
diff changeset
   216
            return forcecwd
39818
24e493ec2229 py3: rename pycompat.getcwd() to encoding.getcwd() (API)
Matt Harbison <matt_harbison@yahoo.com>
parents: 39452
diff changeset
   217
        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
   218
870
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
   219
    def getcwd(self):
26293
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents: 25877
diff changeset
   220
        '''Return the path from which a canonical path is calculated.
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents: 25877
diff changeset
   221
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents: 25877
diff changeset
   222
        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
   223
        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
   224
        used to get real file paths. Use vfs functions instead.
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents: 25877
diff changeset
   225
        '''
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
   226
        cwd = self._cwd
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   227
        if cwd == self._root:
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   228
            return ''
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   229
        # 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
   230
        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
   231
        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
   232
            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
   233
        if cwd.startswith(rootsep):
c93562fb12cc Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4229
diff changeset
   234
            return cwd[len(rootsep):]
c93562fb12cc Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4229
diff changeset
   235
        else:
c93562fb12cc Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4229
diff changeset
   236
            # 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
   237
            return cwd
870
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
   238
4525
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4507
diff changeset
   239
    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
   240
        if cwd is None:
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4507
diff changeset
   241
            cwd = self.getcwd()
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   242
        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
   243
        if self._slash:
19210
865beb849720 dirstate: don't overnormalize for ui.slash
Matt Mackall <mpm@selenic.com>
parents: 19128
diff changeset
   244
            return util.pconvert(path)
4527
b422b558015b Add ui.slash hgrc setting
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4525
diff changeset
   245
        return path
4525
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4507
diff changeset
   246
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   247
    def __getitem__(self, key):
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   248
        '''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
   249
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   250
        States are:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   251
          n  normal
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   252
          m  needs merging
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   253
          r  marked for removal
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   254
          a  marked for addition
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   255
          ?  not tracked
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   256
        '''
4906
30847b8af7ca dirstate: add __contains__ and make __getitem__ more useful
Matt Mackall <mpm@selenic.com>
parents: 4905
diff changeset
   257
        return self._map.get(key, ("?",))[0]
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
   258
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
   259
    def __contains__(self, key):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   260
        return key in self._map
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   261
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   262
    def __iter__(self):
33707
36d216dcae6a dirstate: simplify dirstate's __iter__
Alex Gaynor <agaynor@mozilla.com>
parents: 33440
diff changeset
   263
        return iter(sorted(self._map))
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
   264
32550
b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents: 32372
diff changeset
   265
    def items(self):
18792
10669e24eb6c completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents: 18760
diff changeset
   266
        return self._map.iteritems()
10669e24eb6c completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents: 18760
diff changeset
   267
32550
b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents: 32372
diff changeset
   268
    iteritems = items
b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents: 32372
diff changeset
   269
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
   270
    def parents(self):
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 12907
diff changeset
   271
        return [self._validate(p) for p in self._pl]
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
   272
13876
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   273
    def p1(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   274
        return self._validate(self._pl[0])
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   275
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   276
    def p2(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   277
        return self._validate(self._pl[1])
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   278
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
   279
    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
   280
        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
   281
1062
6d5a62a549fa pep-0008 cleanup
benoit.boissinot@ens-lyon.fr
parents: 1040
diff changeset
   282
    def setparents(self, p1, p2=nullid):
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   283
        """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
   284
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   285
        When moving from two parents to one, 'm' merged entries a
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   286
        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
   287
        returned by the call.
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   288
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   289
        See localrepo.setparents()
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   290
        """
22407
d259322a394b dirstate: add exception when calling setparent without begin/end (API)
Durham Goode <durham@fb.com>
parents: 22404
diff changeset
   291
        if self._parentwriters == 0:
41951
42dd69985778 dirstate: remove obsolete reference to dirstate.beginparentchange
Martin von Zweigbergk <martinvonz@google.com>
parents: 41676
diff changeset
   292
            raise ValueError("cannot set dirstate parent outside of "
42dd69985778 dirstate: remove obsolete reference to dirstate.beginparentchange
Martin von Zweigbergk <martinvonz@google.com>
parents: 41676
diff changeset
   293
                             "dirstate.parentchange context manager")
22407
d259322a394b dirstate: add exception when calling setparent without begin/end (API)
Durham Goode <durham@fb.com>
parents: 22404
diff changeset
   294
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
   295
        self._dirty = True
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   296
        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
   297
        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
   298
            self._origpl = self._pl
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
   299
        self._map.setparents(p1, p2)
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   300
        copies = {}
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   301
        if oldp2 != nullid and p2 == nullid:
34674
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
   302
            candidatefiles = self._map.nonnormalset.union(
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
   303
                                self._map.otherparentset)
31278
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31208
diff changeset
   304
            for f in candidatefiles:
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31208
diff changeset
   305
                s = self._map.get(f)
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31208
diff changeset
   306
                if s is None:
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31208
diff changeset
   307
                    continue
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31208
diff changeset
   308
22895
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
   309
                # Discard 'm' markers when moving away from a merge state
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   310
                if s[0] == 'm':
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   311
                    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
   312
                    if source:
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 33737
diff changeset
   313
                        copies[f] = source
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   314
                    self.normallookup(f)
22895
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
   315
                # Also fix up otherparent markers
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
   316
                elif s[0] == 'n' and s[2] == -2:
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   317
                    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
   318
                    if source:
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 33737
diff changeset
   319
                        copies[f] = source
22895
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
   320
                    self.add(f)
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   321
        return copies
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
   322
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
   323
    def setbranch(self, branch):
40424
7caf632e30c3 filecache: unimplement __set__() and __delete__() (API)
Yuya Nishihara <yuya@tcha.org>
parents: 39818
diff changeset
   324
        self.__class__._branch.set(self, encoding.fromlocal(branch))
29302
083e107adaac dirstate: make writing branch file out avoid ambiguity of file stat
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 29301
diff changeset
   325
        f = self._opener('branch', 'w', atomictemp=True, checkambig=True)
16472
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   326
        try:
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   327
            f.write(self._branch + '\n')
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   328
            f.close()
18317
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   329
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   330
            # 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
   331
            # replacing the underlying file
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   332
            ce = self._filecache['_branch']
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   333
            if ce:
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   334
                ce.refresh()
18076
3bc21f6daac4 dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents: 17984
diff changeset
   335
        except: # re-raises
3bc21f6daac4 dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents: 17984
diff changeset
   336
            f.discard()
3bc21f6daac4 dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents: 17984
diff changeset
   337
            raise
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
   338
4613
3a645af7fb76 localrepo and dirstate: rename reload to invalidate
Matt Mackall <mpm@selenic.com>
parents: 4612
diff changeset
   339
    def invalidate(self):
32682
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32605
diff changeset
   340
        '''Causes the next access to reread the dirstate.
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32605
diff changeset
   341
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32605
diff changeset
   342
        This is different from localrepo.invalidatedirstate() because it always
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32605
diff changeset
   343
        rereads the dirstate. Use localrepo.invalidatedirstate() if you want to
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32605
diff changeset
   344
        check whether the dirstate has changed before rereading it.'''
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32605
diff changeset
   345
35835
bf367a93f000 dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents: 35086
diff changeset
   346
        for a in (r"_map", r"_branch", r"_ignore"):
4953
6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4952
diff changeset
   347
            if a in self.__dict__:
6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4952
diff changeset
   348
                delattr(self, a)
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
   349
        self._lastnormaltime = 0
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
   350
        self._dirty = False
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
   351
        self._updatedfiles.clear()
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   352
        self._parentwriters = 0
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   353
        self._origpl = None
4375
109077e7048d When reloading the dirstate, recompute ignore information if needed.
Bryan O'Sullivan <bos@serpentine.com>
parents: 4374
diff changeset
   354
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
   355
    def copy(self, source, dest):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   356
        """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
   357
        if source == dest:
deda205a00e1 Ignore dummy copies in dirstate and localrepo.filecommit()
Patrick Mezard <pmezard@gmail.com>
parents: 6479
diff changeset
   358
            return
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
   359
        self._dirty = True
7566
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents: 7280
diff changeset
   360
        if source is not None:
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   361
            self._map.copymap[dest] = source
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
   362
            self._updatedfiles.add(source)
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
   363
            self._updatedfiles.add(dest)
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   364
        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
   365
            self._updatedfiles.add(dest)
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
   366
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
   367
    def copied(self, file):
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   368
        return self._map.copymap.get(file, None)
3154
b1f10d3223c1 dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents: 2962
diff changeset
   369
b1f10d3223c1 dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents: 2962
diff changeset
   370
    def copies(self):
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   371
        return self._map.copymap
515
03f27b1381f9 Whitespace cleanups
mpm@selenic.com
parents: 514
diff changeset
   372
17196
2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents: 17094
diff changeset
   373
    def _addpath(self, f, state, mode, size, mtime):
5487
7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660).
Maxim Dounin <mdounin@mdounin.ru>
parents: 5396
diff changeset
   374
        oldstate = self[f]
17196
2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents: 17094
diff changeset
   375
        if state == 'a' or oldstate == 'r':
13974
23f2736abce3 move checkfilename from util to scmutil
Adrian Buehlmann <adrian@cadifra.com>
parents: 13944
diff changeset
   376
            scmutil.checkfilename(f)
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
   377
            if self._map.hastrackeddir(f):
36995
d5d42c170f4d py3: use pycompat.bytestr() in dirstate.py
Pulkit Goyal <7895pulkit@gmail.com>
parents: 36781
diff changeset
   378
                raise error.Abort(_('directory %r already in dirstate') %
d5d42c170f4d py3: use pycompat.bytestr() in dirstate.py
Pulkit Goyal <7895pulkit@gmail.com>
parents: 36781
diff changeset
   379
                                  pycompat.bytestr(f))
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   380
            # shadows
24635
21e1ece30f8c util: move dirs() and finddirs() from scmutil to util
Drew Gottlieb <drgott@google.com>
parents: 24632
diff changeset
   381
            for d in util.finddirs(f):
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
   382
                if self._map.hastrackeddir(d):
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   383
                    break
34188
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   384
                entry = self._map.get(d)
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   385
                if entry is not None and entry[0] != 'r':
26587
56b2bcea2529 error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26521
diff changeset
   386
                    raise error.Abort(
36995
d5d42c170f4d py3: use pycompat.bytestr() in dirstate.py
Pulkit Goyal <7895pulkit@gmail.com>
parents: 36781
diff changeset
   387
                        _('file %r in dirstate clashes with %r') %
d5d42c170f4d py3: use pycompat.bytestr() in dirstate.py
Pulkit Goyal <7895pulkit@gmail.com>
parents: 36781
diff changeset
   388
                        (pycompat.bytestr(d), pycompat.bytestr(f)))
17094
c2016bae3b97 dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents: 16955
diff changeset
   389
        self._dirty = True
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
   390
        self._updatedfiles.add(f)
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
   391
        self._map.addfile(f, oldstate, state, mode, size, mtime)
5487
7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660).
Maxim Dounin <mdounin@mdounin.ru>
parents: 5396
diff changeset
   392
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   393
    def normal(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   394
        '''Mark a file normal and clean.'''
4905
fc61495ea9cf dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents: 4904
diff changeset
   395
        s = os.lstat(self._join(f))
36781
ffa3026d4196 cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime
Augie Fackler <augie@google.com>
parents: 36622
diff changeset
   396
        mtime = s[stat.ST_MTIME]
17733
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents: 17197
diff changeset
   397
        self._addpath(f, 'n', s.st_mode,
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents: 17197
diff changeset
   398
                      s.st_size & _rangemask, mtime & _rangemask)
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   399
        self._map.copymap.pop(f, None)
34674
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
   400
        if f in self._map.nonnormalset:
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
   401
            self._map.nonnormalset.remove(f)
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   402
        if mtime > self._lastnormaltime:
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   403
            # Remember the most recent modification timeslot for status(),
13754
ae157ca56cd5 dirstate: check mtime when adding to _lastnormal
Adrian Buehlmann <adrian@cadifra.com>
parents: 13743
diff changeset
   404
            # to make sure we won't miss future size-preserving file content
ae157ca56cd5 dirstate: check mtime when adding to _lastnormal
Adrian Buehlmann <adrian@cadifra.com>
parents: 13743
diff changeset
   405
            # modifications that happen within the same timeslot.
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   406
            self._lastnormaltime = mtime
13704
a464763e99f1 dirstate: avoid a race with multiple commits in the same process
Greg Ward <greg@gerg.ca>
parents: 13400
diff changeset
   407
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
   408
    def normallookup(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   409
        '''Mark a file normal, but possibly dirty.'''
34188
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   410
        if self._pl[1] != nullid:
6298
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   411
            # if there is a merge going on and the file was either
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   412
            # in state 'm' (-1) or coming from other parent (-2) before
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   413
            # 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
   414
            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
   415
            if entry is not None:
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   416
                if entry[0] == 'r' and entry[2] in (-1, -2):
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   417
                    source = self._map.copymap.get(f)
34188
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   418
                    if entry[2] == -1:
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   419
                        self.merge(f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   420
                    elif entry[2] == -2:
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   421
                        self.otherparent(f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   422
                    if source:
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   423
                        self.copy(source, f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   424
                    return
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   425
                if entry[0] == 'm' or entry[0] == 'n' and entry[2] == -2:
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   426
                    return
17094
c2016bae3b97 dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents: 16955
diff changeset
   427
        self._addpath(f, 'n', 0, -1, -1)
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   428
        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
   429
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   430
    def otherparent(self, f):
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   431
        '''Mark as coming from the other parent, always dirty.'''
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   432
        if self._pl[1] == nullid:
26587
56b2bcea2529 error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26521
diff changeset
   433
            raise error.Abort(_("setting %r to other parent "
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   434
                               "only allowed in merges") % f)
22896
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   435
        if f in self and self[f] == 'n':
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   436
            # merge-like
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   437
            self._addpath(f, 'm', 0, -2, -1)
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   438
        else:
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   439
            # add-like
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   440
            self._addpath(f, 'n', 0, -2, -1)
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   441
        self._map.copymap.pop(f, None)
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   442
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   443
    def add(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   444
        '''Mark a file added.'''
17196
2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents: 17094
diff changeset
   445
        self._addpath(f, 'a', 0, -1, -1)
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   446
        self._map.copymap.pop(f, None)
4616
70352337934e dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents: 4615
diff changeset
   447
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   448
    def remove(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   449
        '''Mark a file removed.'''
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   450
        self._dirty = True
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
   451
        oldstate = self[f]
6297
fed1a9c22076 dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6257
diff changeset
   452
        size = 0
34188
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   453
        if self._pl[1] != nullid:
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   454
            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
   455
            if entry is not None:
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   456
                # backup the previous state
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   457
                if entry[0] == 'm': # merge
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   458
                    size = -1
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   459
                elif entry[0] == 'n' and entry[2] == -2: # other parent
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
   460
                    size = -2
34674
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
   461
                    self._map.otherparentset.add(f)
35083
e8ae0b2d88a8 dirstate: remove _droppath method
Mark Thomas <mbthomas@fb.com>
parents: 35082
diff changeset
   462
        self._updatedfiles.add(f)
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
   463
        self._map.removefile(f, oldstate, size)
33981
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 33737
diff changeset
   464
        if size == 0:
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   465
            self._map.copymap.pop(f, None)
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   466
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   467
    def merge(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   468
        '''Mark a file merged.'''
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   469
        if self._pl[1] == nullid:
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   470
            return self.normallookup(f)
22897
8fe74328f700 dirstate: merge falls through to otherparent
Matt Mackall <mpm@selenic.com>
parents: 22896
diff changeset
   471
        return self.otherparent(f)
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   472
14434
cc8c09855d19 dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents: 14273
diff changeset
   473
    def drop(self, f):
cc8c09855d19 dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents: 14273
diff changeset
   474
        '''Drop a file from the dirstate'''
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
   475
        oldstate = self[f]
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
   476
        if self._map.dropfile(f, oldstate):
15399
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents: 15337
diff changeset
   477
            self._dirty = True
35083
e8ae0b2d88a8 dirstate: remove _droppath method
Mark Thomas <mbthomas@fb.com>
parents: 35082
diff changeset
   478
            self._updatedfiles.add(f)
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
   479
            self._map.copymap.pop(f, None)
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   480
24538
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   481
    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
   482
        if exists is None:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   483
            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
   484
        if not exists:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   485
            # Maybe a path component exists
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   486
            if not ignoremissing and '/' in path:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   487
                d, f = path.rsplit('/', 1)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   488
                d = self._normalize(d, False, ignoremissing, None)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   489
                folded = d + "/" + f
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   490
            else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   491
                # No path components, preserve original case
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   492
                folded = path
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   493
        else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   494
            # recursively normalize leading directory components
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   495
            # against dirstate
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   496
            if '/' in normed:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   497
                d, f = normed.rsplit('/', 1)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   498
                d = self._normalize(d, False, ignoremissing, True)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   499
                r = self._root + "/" + d
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   500
                folded = d + "/" + util.fspath(f, r)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   501
            else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   502
                folded = util.fspath(normed, self._root)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   503
            storemap[normed] = folded
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   504
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   505
        return folded
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   506
24539
3a8eba78803e dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents: 24538
diff changeset
   507
    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
   508
        normed = util.normcase(path)
34676
bfddc3d678ae dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents: 34675
diff changeset
   509
        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
   510
        if folded is None:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   511
            if isknown:
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   512
                folded = path
7068
57377fa7eda2 issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents: 7034
diff changeset
   513
            else:
24539
3a8eba78803e dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents: 24538
diff changeset
   514
                folded = self._discoverpath(path, normed, ignoremissing, exists,
34676
bfddc3d678ae dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents: 34675
diff changeset
   515
                                            self._map.filefoldmap)
24539
3a8eba78803e dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents: 24538
diff changeset
   516
        return folded
16302
49b54f1ae053 dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents: 16258
diff changeset
   517
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   518
    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
   519
        normed = util.normcase(path)
34676
bfddc3d678ae dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents: 34675
diff changeset
   520
        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
   521
        if folded is None:
34678
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
   522
            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
   523
        if folded is None:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   524
            if isknown:
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   525
                folded = path
7068
57377fa7eda2 issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents: 7034
diff changeset
   526
            else:
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   527
                # 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
   528
                # normalizefile calls don't start matching directories
24538
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   529
                folded = self._discoverpath(path, normed, ignoremissing, exists,
34678
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
   530
                                            self._map.dirfoldmap)
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   531
        return folded
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   532
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   533
    def normalize(self, path, isknown=False, ignoremissing=False):
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   534
        '''
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   535
        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
   536
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   537
        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
   538
        disk, to avoid extra filesystem access.
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   539
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   540
        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
   541
        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
   542
        existing path components.
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   543
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   544
        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
   545
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   546
        - 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
   547
        - version of name stored on disk
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   548
        - version provided via command arguments
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   549
        '''
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   550
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   551
        if self._checkcase:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   552
            return self._normalize(path, isknown, ignoremissing)
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   553
        return path
6677
9865e15febd0 Add a normalize() method to dirstate
Paul Moore <p.f.moore@gmail.com>
parents: 6675
diff changeset
   554
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   555
    def clear(self):
34933
0217f75b6e59 dirstate: move clear onto dirstatemap class
Durham Goode <durham@fb.com>
parents: 34678
diff changeset
   556
        self._map.clear()
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
   557
        self._lastnormaltime = 0
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
   558
        self._updatedfiles.clear()
5123
79373ec3f27d merge with crew-stable
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5045 5065
diff changeset
   559
        self._dirty = True
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   560
18760
e74704c33e24 strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents: 18663
diff changeset
   561
    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
   562
        if changedfiles is None:
27176
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   563
            # Rebuild entire dirstate
25448
2bbfc2042d93 dirstate: avoid invalidating every entries when list is empty
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25275
diff changeset
   564
            changedfiles = allfiles
27176
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   565
            lastnormaltime = self._lastnormaltime
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   566
            self.clear()
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   567
            self._lastnormaltime = lastnormaltime
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   568
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   569
        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
   570
            self._origpl = self._pl
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
   571
        self._map.setparents(parent, nullid)
30026
ba06562a06a2 dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents: 29889
diff changeset
   572
        for f in changedfiles:
ba06562a06a2 dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents: 29889
diff changeset
   573
            if f in allfiles:
ba06562a06a2 dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents: 29889
diff changeset
   574
                self.normallookup(f)
ba06562a06a2 dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents: 29889
diff changeset
   575
            else:
ba06562a06a2 dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents: 29889
diff changeset
   576
                self.drop(f)
ba06562a06a2 dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents: 29889
diff changeset
   577
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
   578
        self._dirty = True
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   579
32750
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32682
diff changeset
   580
    def identity(self):
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32682
diff changeset
   581
        '''Return identity of dirstate itself to detect changing in storage
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32682
diff changeset
   582
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32682
diff changeset
   583
        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
   584
        changes based on the former dirstate out can keep consistency.
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32682
diff changeset
   585
        '''
34675
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
   586
        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
   587
29673
52ff07e1de91 deprecation: enforce thew 'tr' argument of 'dirstate.write' (API)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 29351
diff changeset
   588
    def write(self, tr):
4612
17ee7407097f dirstate: simplify dirty handling
Matt Mackall <mpm@selenic.com>
parents: 4611
diff changeset
   589
        if not self._dirty:
1794
98b6c1cad58b only write the dirstate when something changed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1755
diff changeset
   590
            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
   591
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   592
        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
   593
        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
   594
            # '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
   595
            # 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
   596
            # 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
   597
            # 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
   598
            # 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
   599
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   600
            # 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
   601
            now = _getfsnow(self._opener)
35080
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
   602
            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
   603
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   604
            # 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
   605
            self._lastnormaltime = 0
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
   606
            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
   607
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   608
            # delay writing in-memory changes out
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   609
            tr.addfilegenerator('dirstate', (self._filename,),
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   610
                                self._writedirstate, location='plain')
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   611
            return
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   612
29301
28f37ffc0a91 dirstate: make writing dirstate file out avoid ambiguity of file stat
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 29273
diff changeset
   613
        st = self._opener(filename, "w", atomictemp=True, checkambig=True)
26521
3f41e28a16d8 dirstate: split write to write changes into files other than .hg/dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26492
diff changeset
   614
        self._writedirstate(st)
3f41e28a16d8 dirstate: split write to write changes into files other than .hg/dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26492
diff changeset
   615
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   616
    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
   617
        """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
   618
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   619
        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
   620
            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
   621
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   622
        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
   623
        with a newer callback.
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   624
        """
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   625
        self._plchangecallbacks[category] = callback
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   626
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
   627
    def _writedirstate(self, st):
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   628
        # 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
   629
        if self._origpl is not None and self._origpl != self._pl:
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   630
            for c, callback in sorted(self._plchangecallbacks.iteritems()):
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
   631
                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
   632
            self._origpl = None
9509
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   633
        # 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
   634
        # 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
   635
        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
   636
6c6b48aca328 dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents: 27176
diff changeset
   637
        # 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
   638
        # timestamp of each entries in dirstate, because of 'now > mtime'
34480
cbda631c1dde configitems: register the 'debug.dirstate.delaywrite' config
Boris Feld <boris.feld@octobus.net>
parents: 34408
diff changeset
   639
        delaywrite = self._ui.configint('debug', 'dirstate.delaywrite')
27397
6c6b48aca328 dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents: 27176
diff changeset
   640
        if delaywrite > 0:
27398
c81675776c95 dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents: 27397
diff changeset
   641
            # do we have any files to delay for?
c81675776c95 dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents: 27397
diff changeset
   642
            for f, e in self._map.iteritems():
c81675776c95 dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents: 27397
diff changeset
   643
                if e[0] == 'n' and e[3] == now:
c81675776c95 dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents: 27397
diff changeset
   644
                    import time # to avoid useless import
27399
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
   645
                    # 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
   646
                    # 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
   647
                    clock = time.time()
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
   648
                    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
   649
                    end = start + delaywrite
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
   650
                    time.sleep(end - clock)
30224
ad56071b37d4 dirstate: fix debug.dirstate.delaywrite to use the new "now" after sleeping
Mads Kiilerich <madski@unity3d.com>
parents: 30026
diff changeset
   651
                    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
   652
                    break
27397
6c6b48aca328 dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents: 27176
diff changeset
   653
34673
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
   654
        self._map.write(st, now)
21026
7ee03e190c1d dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents: 20632
diff changeset
   655
        self._lastnormaltime = 0
34673
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
   656
        self._dirty = False
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   657
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   658
    def _dirignore(self, f):
6479
31abcae33b4f dirstate: do not ignore current directory '.' (issue 1078)
Patrick Mezard <pmezard@gmail.com>
parents: 6327
diff changeset
   659
        if f == '.':
31abcae33b4f dirstate: do not ignore current directory '.' (issue 1078)
Patrick Mezard <pmezard@gmail.com>
parents: 6327
diff changeset
   660
            return False
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   661
        if self._ignore(f):
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   662
            return True
24635
21e1ece30f8c util: move dirs() and finddirs() from scmutil to util
Drew Gottlieb <drgott@google.com>
parents: 24632
diff changeset
   663
        for p in util.finddirs(f):
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   664
            if self._ignore(p):
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   665
                return True
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   666
        return False
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   667
27594
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   668
    def _ignorefiles(self):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   669
        files = []
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   670
        if os.path.exists(self._join('.hgignore')):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   671
            files.append(self._join('.hgignore'))
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   672
        for name, path in self._ui.configitems("ui"):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   673
            if name == 'ignore' or name.startswith('ignore.'):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   674
                # 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
   675
                # 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
   676
                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
   677
        return files
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   678
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
   679
    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
   680
        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
   681
        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
   682
        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
   683
            i = files.popleft()
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   684
            patterns = matchmod.readpatternfile(i, self._ui.warn,
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   685
                                                sourceinfo=True)
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   686
            for pattern, lineno, line in patterns:
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   687
                kind, p = matchmod._patsplit(pattern, 'glob')
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   688
                if kind == "subinclude":
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   689
                    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
   690
                        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
   691
                    continue
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   692
                m = matchmod.match(self._root, '', [], [pattern],
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   693
                                   warn=self._ui.warn)
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   694
                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
   695
                    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
   696
            visited.add(i)
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   697
        return (None, -1, "")
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   698
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   699
    def _walkexplicit(self, match, subrepos):
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   700
        '''Get stat data about the files explicitly specified by match.
3529
09d99b7e4da0 simplify dirstate walking
Matt Mackall <mpm@selenic.com>
parents: 3223
diff changeset
   701
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   702
        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
   703
        - 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
   704
          listings mapping subrepos and .hg to None.
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   705
        - 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
   706
        - dirsnotfound is a list of files that the dirstate thinks are
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   707
          directories and that were not found.'''
6578
f242d3684f83 walk: begin refactoring badmatch handling
Matt Mackall <mpm@selenic.com>
parents: 6577
diff changeset
   708
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
   709
        def badtype(mode):
8310
8417d82d3969 dirstate: translate forgotten string
Simon Heimberg <simohe@besonet.ch>
parents: 8261
diff changeset
   710
            kind = _('unknown')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   711
            if stat.S_ISCHR(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   712
                kind = _('character device')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   713
            elif stat.S_ISBLK(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   714
                kind = _('block device')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   715
            elif stat.S_ISFIFO(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   716
                kind = _('fifo')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   717
            elif stat.S_ISSOCK(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   718
                kind = _('socket')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   719
            elif stat.S_ISDIR(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   720
                kind = _('directory')
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
   721
            return _('unsupported file type (type is %s)') % kind
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   722
19142
c3d3e4d75ec3 dirstate.walk: cache match.explicitdir and traversedir locally
Siddharth Agarwal <sid0@fb.com>
parents: 19137
diff changeset
   723
        matchedir = match.explicitdir
8676
acd69fc201a5 walk: we always have a badfn
Matt Mackall <mpm@selenic.com>
parents: 8675
diff changeset
   724
        badfn = match.bad
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   725
        dmap = self._map
5000
46facb73ba8b dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents: 4965
diff changeset
   726
        lstat = os.lstat
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   727
        getkind = stat.S_IFMT
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
   728
        dirkind = stat.S_IFDIR
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   729
        regkind = stat.S_IFREG
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   730
        lnkkind = stat.S_IFLNK
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   731
        join = self._join
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   732
        dirsfound = []
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   733
        foundadd = dirsfound.append
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   734
        dirsnotfound = []
19175
63f7bd2e1a46 dirstate._walkexplicit: inline dirsnotfound.append
Siddharth Agarwal <sid0@fb.com>
parents: 19174
diff changeset
   735
        notfoundadd = dirsnotfound.append
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   736
24448
55c449345b10 match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents: 24212
diff changeset
   737
        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
   738
            normalize = self._normalize
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
   739
        else:
18032
a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents: 18018
diff changeset
   740
            normalize = None
12907
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
   741
12211
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   742
        files = sorted(match.files())
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   743
        subrepos.sort()
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   744
        i, j = 0, 0
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   745
        while i < len(files) and j < len(subrepos):
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   746
            subpath = subrepos[j] + "/"
13233
0b30e6148ec5 subrepo: do not report known files inside repositories as unknown
Oleg Stepanov <oleg.stepanov@jetbrains.com>
parents: 12907
diff changeset
   747
            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
   748
                i += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   749
                continue
13339
22167be007ed subrepo: fix pruning of subrepo filenames in dirstate (issue2619)
trbs <trbs@trbs.net>
parents: 13233
diff changeset
   750
            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
   751
                del files[i]
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   752
            j += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   753
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   754
        if not files or '.' in files:
24521
489026bffbf6 dirstate._walkexplicit: indicate root as '.', not ''
Siddharth Agarwal <sid0@fb.com>
parents: 24448
diff changeset
   755
            files = ['.']
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
   756
        results = dict.fromkeys(subrepos)
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
   757
        results['.hg'] = None
5000
46facb73ba8b dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents: 4965
diff changeset
   758
12211
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   759
        for ff in files:
24523
a4b81dbe73c1 dirstate._walkexplicit: don't bother normalizing '.'
Siddharth Agarwal <sid0@fb.com>
parents: 24522
diff changeset
   760
            # constructing the foldmap is expensive, so don't do it for the
a4b81dbe73c1 dirstate._walkexplicit: don't bother normalizing '.'
Siddharth Agarwal <sid0@fb.com>
parents: 24522
diff changeset
   761
            # common case where files is ['.']
a4b81dbe73c1 dirstate._walkexplicit: don't bother normalizing '.'
Siddharth Agarwal <sid0@fb.com>
parents: 24522
diff changeset
   762
            if normalize and ff != '.':
24522
18085e46caa9 dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents: 24521
diff changeset
   763
                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
   764
            else:
24522
18085e46caa9 dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents: 24521
diff changeset
   765
                nf = ff
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
   766
            if nf in results:
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   767
                continue
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   768
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   769
            try:
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   770
                st = lstat(join(nf))
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   771
                kind = getkind(st.st_mode)
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   772
                if kind == dirkind:
8588
2624f485b9bc dirstate: set more states in step 1 of walk
Simon Heimberg <simohe@besonet.ch>
parents: 8521
diff changeset
   773
                    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
   774
                        # 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
   775
                        results[nf] = None
19143
3cb9468535bd match: make explicitdir and traversedir None by default
Siddharth Agarwal <sid0@fb.com>
parents: 19142
diff changeset
   776
                    if matchedir:
3cb9468535bd match: make explicitdir and traversedir None by default
Siddharth Agarwal <sid0@fb.com>
parents: 19142
diff changeset
   777
                        matchedir(nf)
24537
2bb13f2b778c dirstate: don't require exact case when adding dirs on icasefs (issue4578)
Matt Harbison <matt_harbison@yahoo.com>
parents: 24198
diff changeset
   778
                    foundadd((nf, ff))
12401
4cdaf1adafc8 backout most of 4f8067c94729
Matt Mackall <mpm@selenic.com>
parents: 12387
diff changeset
   779
                elif kind == regkind or kind == lnkkind:
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   780
                    results[nf] = st
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
   781
                else:
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
   782
                    badfn(ff, badtype(kind))
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   783
                    if nf in dmap:
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
   784
                        results[nf] = None
25660
328739ea70c3 global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25658
diff changeset
   785
            except OSError as inst: # nf not found on disk - it is dirstate only
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   786
                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
   787
                    results[nf] = None
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   788
                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
   789
                    if self._map.hasdir(nf):
23375
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
   790
                        if matchedir:
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
   791
                            matchedir(nf)
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
   792
                        notfoundadd(nf)
8677
34df078b8b1b walk: simplify logic for badfn clause
Matt Mackall <mpm@selenic.com>
parents: 8676
diff changeset
   793
                    else:
34022
d5b2beca16c0 python3: wrap all uses of <exception>.strerror with strtolocal
Augie Fackler <raf@durin42.com>
parents: 33981
diff changeset
   794
                        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
   795
36200
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
   796
        # 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
   797
        # 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
   798
        # 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
   799
        if match.anypats():
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
   800
            for f in list(results):
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
   801
                if f == '.hg' or f in subrepos:
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
   802
                    # 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
   803
                    continue
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
   804
                if not match(f):
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
   805
                    del results[f]
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
   806
25877
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   807
        # 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
   808
        # 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
   809
        # 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
   810
        # 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
   811
        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
   812
            normed = {}
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   813
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   814
            for f, st in results.iteritems():
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   815
                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
   816
                    continue
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   817
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   818
                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
   819
                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
   820
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   821
                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
   822
                    paths = set()
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   823
                    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
   824
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   825
                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
   826
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   827
            for norm, paths in normed.iteritems():
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   828
                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
   829
                    for path in paths:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   830
                        folded = self._discoverpath(path, norm, True, None,
34678
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
   831
                                                    self._map.dirfoldmap)
25877
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   832
                        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
   833
                            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
   834
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   835
        return results, dirsfound, dirsnotfound
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   836
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
   837
    def walk(self, match, subrepos, unknown, ignored, full=True):
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   838
        '''
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   839
        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
   840
        matched by match.
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   841
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
   842
        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
   843
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   844
        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
   845
        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
   846
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   847
        '''
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
   848
        # 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
   849
        # 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
   850
        # 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
   851
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   852
        if ignored:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   853
            ignore = util.never
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   854
            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
   855
        elif unknown:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   856
            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
   857
            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
   858
        else:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   859
            # 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
   860
            ignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   861
            dirignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   862
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   863
        matchfn = match.matchfn
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   864
        matchalways = match.always()
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   865
        matchtdir = match.traversedir
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   866
        dmap = self._map
32208
d74b0cff94a9 osutil: proxy through util (and platform) modules (API)
Yuya Nishihara <yuya@tcha.org>
parents: 32177
diff changeset
   867
        listdir = util.listdir
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   868
        lstat = os.lstat
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   869
        dirkind = stat.S_IFDIR
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   870
        regkind = stat.S_IFREG
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   871
        lnkkind = stat.S_IFLNK
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   872
        join = self._join
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   873
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   874
        exact = skipstep3 = False
24448
55c449345b10 match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents: 24212
diff changeset
   875
        if match.isexact(): # match.exact
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   876
            exact = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   877
            dirignore = util.always # skip step 2
25234
3c346969c321 dirstate: avoid match.files() in walk()
Martin von Zweigbergk <martinvonz@google.com>
parents: 25227
diff changeset
   878
        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
   879
            skipstep3 = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   880
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   881
        if not exact and self._checkcase:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   882
            normalize = self._normalize
24541
e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents: 24540
diff changeset
   883
            normalizefile = self._normalizefile
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   884
            skipstep3 = False
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   885
        else:
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   886
            normalize = self._normalize
24541
e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents: 24540
diff changeset
   887
            normalizefile = None
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   888
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   889
        # step 1: find all explicit files
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   890
        results, work, dirsnotfound = self._walkexplicit(match, subrepos)
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   891
19172
c6cea2e2031b dirstate.walk: pull skipstep3 out of the explicit walk code
Siddharth Agarwal <sid0@fb.com>
parents: 19171
diff changeset
   892
        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
   893
        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
   894
6826
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents: 6825
diff changeset
   895
        # 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
   896
        def traverse(work, alreadynormed):
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   897
            wadd = work.append
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   898
            while work:
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   899
                nd = work.pop()
38956
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
   900
                visitentries = match.visitchildrenset(nd)
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
   901
                if not visitentries:
32177
8f1a2b848b52 dirstate: optimize walk() by using match.visitdir()
Martin von Zweigbergk <martinvonz@google.com>
parents: 31547
diff changeset
   902
                    continue
38956
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
   903
                if visitentries == 'this' or visitentries == 'all':
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
   904
                    visitentries = None
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   905
                skip = None
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   906
                if nd == '.':
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   907
                    nd = ''
18032
a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents: 18018
diff changeset
   908
                else:
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   909
                    skip = '.hg'
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   910
                try:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   911
                    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
   912
                except OSError as inst:
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   913
                    if inst.errno in (errno.EACCES, errno.ENOENT):
34022
d5b2beca16c0 python3: wrap all uses of <exception>.strerror with strtolocal
Augie Fackler <raf@durin42.com>
parents: 33981
diff changeset
   914
                        match.bad(self.pathto(nd),
d5b2beca16c0 python3: wrap all uses of <exception>.strerror with strtolocal
Augie Fackler <raf@durin42.com>
parents: 33981
diff changeset
   915
                                  encoding.strtolocal(inst.strerror))
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   916
                        continue
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   917
                    raise
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   918
                for f, kind, st in entries:
39260
27946fca8a05 match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents: 38959
diff changeset
   919
                    # 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
   920
                    # 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
   921
                    # 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
   922
                    # 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
   923
                    # 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
   924
                    # 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
   925
                    # 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
   926
                    # they're actually a file or a directory.
38956
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
   927
                    if visitentries and f not in visitentries:
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
   928
                        continue
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   929
                    if normalizefile:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   930
                        # 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
   931
                        # 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
   932
                        # dmap -- therefore normalizefile is enough
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   933
                        nf = normalizefile(nd and (nd + "/" + f) or f, True,
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   934
                                           True)
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   935
                    else:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   936
                        nf = nd and (nd + "/" + f) or f
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   937
                    if nf not in results:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   938
                        if kind == dirkind:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   939
                            if not ignore(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   940
                                if matchtdir:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   941
                                    matchtdir(nf)
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   942
                                wadd(nf)
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   943
                            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
   944
                                results[nf] = None
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   945
                        elif kind == regkind or kind == lnkkind:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   946
                            if nf in dmap:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   947
                                if matchalways or matchfn(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   948
                                    results[nf] = st
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   949
                            elif ((matchalways or matchfn(nf))
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   950
                                  and not ignore(nf)):
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   951
                                # 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
   952
                                if not alreadynormed:
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   953
                                    nf = normalize(nf, False, True)
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   954
                                results[nf] = st
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   955
                        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
   956
                            results[nf] = None
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   957
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   958
        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
   959
            # 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
   960
            # expensive directory normalization
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   961
            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
   962
            traverse([d], alreadynormed)
536
c15b4bc0a11c Refactor diffrevs/diffdir into changes
mpm@selenic.com
parents: 529
diff changeset
   963
18812
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18792
diff changeset
   964
        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
   965
            del results[s]
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18792
diff changeset
   966
        del results['.hg']
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18792
diff changeset
   967
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   968
        # 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
   969
        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
   970
            # 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
   971
            # 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
   972
            # 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
   973
            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
   974
                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
   975
            else:
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
   976
                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
   977
            visit.sort()
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
   978
18625
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
   979
            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
   980
                # 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
   981
                # 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
   982
                # 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
   983
                # 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
   984
                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
   985
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
   986
                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
   987
                    # 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
   988
                    # 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
   989
                    # 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
   990
                    # on disk.
24632
b2fb1403994e merge with stable
Matt Mackall <mpm@selenic.com>
parents: 24610 24621
diff changeset
   991
                    if (normalizefile and
b2fb1403994e merge with stable
Matt Mackall <mpm@selenic.com>
parents: 24610 24621
diff changeset
   992
                        normalizefile(nf, True, True) in results):
24621
1784ca148392 dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents: 24537
diff changeset
   993
                        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
   994
                    # 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
   995
                    # 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
   996
                    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
   997
                        try:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
   998
                            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
   999
                            # 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
  1000
                        except OSError:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
  1001
                            # file doesn't exist
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
  1002
                            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
  1003
                    else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1004
                        # 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
  1005
                        # 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
  1006
                        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
  1007
            else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1008
                # 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
  1009
                # 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
  1010
                iv = iter(visit)
26984
af2663680e95 dirstate: back out 502b56a9e897
Bryan O'Sullivan <bos@serpentine.com>
parents: 26887
diff changeset
  1011
                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
  1012
                    results[next(iv)] = st
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
  1013
        return results
669
8aa2a282eda4 .hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents: 667
diff changeset
  1014
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
  1015
    def status(self, match, subrepos, ignored, clean, unknown):
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1016
        '''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
  1017
        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
  1018
        scmutil.status and:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1019
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1020
          unsure:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1021
            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
  1022
            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
  1023
            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
  1024
          status.modified:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1025
            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
  1026
            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
  1027
          status.clean:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1028
            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
  1029
            dirstate was written
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1030
        '''
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
  1031
        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
  1032
        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
  1033
        removed, deleted, clean = [], [], []
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
  1034
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1035
        dmap = self._map
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1036
        dmap.preload()
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1037
        dcontains = dmap.__contains__
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1038
        dget = dmap.__getitem__
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1039
        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
  1040
        madd = modified.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1041
        aadd = added.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1042
        uadd = unknown.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1043
        iadd = ignored.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1044
        radd = removed.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1045
        dadd = deleted.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1046
        cadd = clean.append
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1047
        mexact = match.exact
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1048
        dirignore = self._dirignore
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1049
        checkexec = self._checkexec
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
  1050
        copymap = self._map.copymap
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1051
        lastnormaltime = self._lastnormaltime
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1052
19191
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
  1053
        # 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
  1054
        # - we're listing all clean files, or
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
  1055
        # - 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
  1056
        #   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
  1057
        full = listclean or match.traversedir is not None
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
  1058
        for fn, st in self.walk(match, subrepos, listunknown, listignored,
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
  1059
                                full=full).iteritems():
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1060
            if not dcontains(fn):
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1061
                if (listignored or mexact(fn)) and dirignore(fn):
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
  1062
                    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
  1063
                        iadd(fn)
19910
601944f41257 dirstate.status: return explicit unknown files even when not asked
Siddharth Agarwal <sid0@fb.com>
parents: 19651
diff changeset
  1064
                else:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1065
                    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
  1066
                continue
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
  1067
21810
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1068
            # 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
  1069
            # 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
  1070
            # 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
  1071
            # 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
  1072
            # 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
  1073
            # 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
  1074
            # 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
  1075
            t = dget(fn)
21810
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1076
            state = t[0]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1077
            mode = t[1]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1078
            size = t[2]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1079
            time = t[3]
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
  1080
6818
6e93fbd847ef dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents: 6811
diff changeset
  1081
            if not st and state in "nma":
6e93fbd847ef dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents: 6811
diff changeset
  1082
                dadd(fn)
6e93fbd847ef dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents: 6811
diff changeset
  1083
            elif state == 'n':
6257
bfd49ce0db64 dirstate: ignore mode changes if the fs does not supports the exec bit
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6212
diff changeset
  1084
                if (size >= 0 and
17733
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents: 17197
diff changeset
  1085
                    ((size != st.st_size and size != st.st_size & _rangemask)
25658
e93036747902 global: mass rewrite to use modern octal syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25585
diff changeset
  1086
                     or ((mode ^ st.st_mode) & 0o100 and checkexec))
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
  1087
                    or size == -2 # other parent
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1088
                    or fn in copymap):
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1089
                    madd(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
  1090
                elif (time != st[stat.ST_MTIME]
ffa3026d4196 cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime
Augie Fackler <augie@google.com>
parents: 36622
diff changeset
  1091
                      and time != st[stat.ST_MTIME] & _rangemask):
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1092
                    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
  1093
                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
  1094
                    # 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
  1095
                    # 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
  1096
                    # This can happen if we quickly do multiple commits.
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
  1097
                    # 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
  1098
                    ladd(fn)
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
  1099
                elif listclean:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1100
                    cadd(fn)
6590
9f80e062d71c status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents: 6589
diff changeset
  1101
            elif state == 'm':
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1102
                madd(fn)
6590
9f80e062d71c status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents: 6589
diff changeset
  1103
            elif state == 'a':
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1104
                aadd(fn)
6590
9f80e062d71c status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents: 6589
diff changeset
  1105
            elif state == 'r':
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1106
                radd(fn)
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
  1107
22913
cb4449921a1d status: create class for status lists
Martin von Zweigbergk <martinvonz@gmail.com>
parents: 22911
diff changeset
  1108
        return (lookup, scmutil.status(modified, added, removed, deleted,
cb4449921a1d status: create class for status lists
Martin von Zweigbergk <martinvonz@gmail.com>
parents: 22911
diff changeset
  1109
                                       unknown, ignored, clean))
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1110
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1111
    def matches(self, match):
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1112
        '''
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1113
        return files in the dirstate (in whatever state) filtered by match
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1114
        '''
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1115
        dmap = self._map
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1116
        if match.always():
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1117
            return dmap.keys()
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1118
        files = match.files()
24448
55c449345b10 match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents: 24212
diff changeset
  1119
        if match.isexact():
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1120
            # 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
  1121
            # much smaller than dmap
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1122
            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
  1123
        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
  1124
            # 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
  1125
            # that
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1126
            return list(files)
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1127
        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
  1128
26746
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
  1129
    def _actualfilename(self, tr):
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
  1130
        if tr:
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1131
            return self._pendingfilename
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1132
        else:
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1133
            return self._filename
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1134
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1135
    def savebackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1136
        '''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
  1137
        filename = self._actualfilename(tr)
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1138
        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
  1139
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1140
        # 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
  1141
        # 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
  1142
        # 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
  1143
        if self._dirty or not self._opener.exists(filename):
fc57a8b95f1b dirstate: avoid unnecessary load+dump during backup
Jun Wu <quark@fb.com>
parents: 31207
diff changeset
  1144
            self._writedirstate(self._opener(filename, "w", atomictemp=True,
fc57a8b95f1b dirstate: avoid unnecessary load+dump during backup
Jun Wu <quark@fb.com>
parents: 31207
diff changeset
  1145
                                             checkambig=True))
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1146
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1147
        if tr:
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1148
            # 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
  1149
            # 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
  1150
            # changed after this
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1151
            tr.addfilegenerator('dirstate', (self._filename,),
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1152
                                self._writedirstate, location='plain')
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1153
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1154
            # 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
  1155
            # 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
  1156
            # end of this transaction
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1157
            tr.registertmp(filename, location='plain')
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1158
31547
ddadb6b0b58e dirstate: use tryunlink
Ryan McElroy <rmcelroy@fb.com>
parents: 31507
diff changeset
  1159
        self._opener.tryunlink(backupname)
31207
1ef37b16b8e8 dirstate: try to use hardlink to backup dirstate
Jun Wu <quark@fb.com>
parents: 31206
diff changeset
  1160
        # 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
  1161
        # with an "atomictemp=True" file.
1ef37b16b8e8 dirstate: try to use hardlink to backup dirstate
Jun Wu <quark@fb.com>
parents: 31206
diff changeset
  1162
        util.copyfile(self._opener.join(filename),
1ef37b16b8e8 dirstate: try to use hardlink to backup dirstate
Jun Wu <quark@fb.com>
parents: 31206
diff changeset
  1163
                      self._opener.join(backupname), hardlink=True)
26632
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26630
diff changeset
  1164
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1165
    def restorebackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1166
        '''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
  1167
        # 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
  1168
        # 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
  1169
        self.invalidate()
26746
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
  1170
        filename = self._actualfilename(tr)
34940
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
  1171
        o = self._opener
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
  1172
        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
  1173
            o.unlink(backupname)
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
  1174
        else:
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
  1175
            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
  1176
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1177
    def clearbackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1178
        '''Clear backup file'''
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
  1179
        self._opener.unlink(backupname)
34332
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1180
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1181
class dirstatemap(object):
35078
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1182
    """Map encapsulating the dirstate's contents.
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1183
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1184
    The dirstate contains the following state:
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1185
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1186
    - `identity` is the identity of the dirstate file, which can be used to
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1187
      detect when changes have occurred to the dirstate file.
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1188
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1189
    - `parents` is a pair containing the parents of the working copy. The
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1190
      parents are updated by calling `setparents`.
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1191
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1192
    - the state map maps filenames to tuples of (state, mode, size, mtime),
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1193
      where state is a single character representing 'normal', 'added',
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1194
      'removed', or 'merged'. It is read by treating the dirstate as a
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1195
      dict.  File state is updated by calling the `addfile`, `removefile` and
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1196
      `dropfile` methods.
35078
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1197
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1198
    - `copymap` maps destination filenames to their source filename.
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1199
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1200
    The dirstate also provides the following views onto the state:
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1201
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1202
    - `nonnormalset` is a set of the filenames that have state other
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1203
      than 'normal', or are normal but have an mtime of -1 ('normallookup').
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1204
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1205
    - `otherparentset` is a set of the filenames that are marked as coming
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1206
      from the second parent when the dirstate is currently being merged.
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1207
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1208
    - `filefoldmap` is a dict mapping normalized filenames to the denormalized
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1209
      form that they appear as in the dirstate.
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1210
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1211
    - `dirfoldmap` is a dict mapping normalized directory names to the
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1212
      denormalized form that they appear as in the dirstate.
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1213
    """
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
  1214
34337
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1215
    def __init__(self, ui, opener, root):
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1216
        self._ui = ui
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1217
        self._opener = opener
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1218
        self._root = root
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1219
        self._filename = 'dirstate'
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1220
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1221
        self._parents = None
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1222
        self._dirtyparents = False
34332
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1223
34337
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1224
        # for consistent view between _pl() and _read() invocations
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1225
        self._pendingmode = None
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1226
34934
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
  1227
    @propertycache
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
  1228
    def _map(self):
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
  1229
        self._map = {}
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
  1230
        self.read()
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
  1231
        return self._map
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
  1232
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
  1233
    @propertycache
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
  1234
    def copymap(self):
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
  1235
        self.copymap = {}
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
  1236
        self._map
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
  1237
        return self.copymap
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
  1238
34933
0217f75b6e59 dirstate: move clear onto dirstatemap class
Durham Goode <durham@fb.com>
parents: 34678
diff changeset
  1239
    def clear(self):
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1240
        self._map.clear()
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1241
        self.copymap.clear()
34933
0217f75b6e59 dirstate: move clear onto dirstatemap class
Durham Goode <durham@fb.com>
parents: 34678
diff changeset
  1242
        self.setparents(nullid, nullid)
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1243
        util.clearcachedproperty(self, "_dirs")
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1244
        util.clearcachedproperty(self, "_alldirs")
35015
ecede5263adb dirstate: clear map cached properties when clearing the map
Mark Thomas <mbthomas@fb.com>
parents: 34940
diff changeset
  1245
        util.clearcachedproperty(self, "filefoldmap")
ecede5263adb dirstate: clear map cached properties when clearing the map
Mark Thomas <mbthomas@fb.com>
parents: 34940
diff changeset
  1246
        util.clearcachedproperty(self, "dirfoldmap")
ecede5263adb dirstate: clear map cached properties when clearing the map
Mark Thomas <mbthomas@fb.com>
parents: 34940
diff changeset
  1247
        util.clearcachedproperty(self, "nonnormalset")
ecede5263adb dirstate: clear map cached properties when clearing the map
Mark Thomas <mbthomas@fb.com>
parents: 34940
diff changeset
  1248
        util.clearcachedproperty(self, "otherparentset")
34933
0217f75b6e59 dirstate: move clear onto dirstatemap class
Durham Goode <durham@fb.com>
parents: 34678
diff changeset
  1249
35878
6e7fae8f1c6c contrib: fix dirstatenonnormalcheck to work in Python 3
Augie Fackler <augie@google.com>
parents: 35835
diff changeset
  1250
    def items(self):
34332
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1251
        return self._map.iteritems()
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1252
35878
6e7fae8f1c6c contrib: fix dirstatenonnormalcheck to work in Python 3
Augie Fackler <augie@google.com>
parents: 35835
diff changeset
  1253
    # forward for python2,3 compat
6e7fae8f1c6c contrib: fix dirstatenonnormalcheck to work in Python 3
Augie Fackler <augie@google.com>
parents: 35835
diff changeset
  1254
    iteritems = items
6e7fae8f1c6c contrib: fix dirstatenonnormalcheck to work in Python 3
Augie Fackler <augie@google.com>
parents: 35835
diff changeset
  1255
34408
7d2f71b7bc31 dirstate: implement __len__ on dirstatemap (issue5695)
Simon Whitaker <swhitaker@fb.com>
parents: 34339
diff changeset
  1256
    def __len__(self):
7d2f71b7bc31 dirstate: implement __len__ on dirstatemap (issue5695)
Simon Whitaker <swhitaker@fb.com>
parents: 34339
diff changeset
  1257
        return len(self._map)
7d2f71b7bc31 dirstate: implement __len__ on dirstatemap (issue5695)
Simon Whitaker <swhitaker@fb.com>
parents: 34339
diff changeset
  1258
34332
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1259
    def __iter__(self):
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1260
        return iter(self._map)
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1261
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1262
    def get(self, key, default=None):
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1263
        return self._map.get(key, default)
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1264
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1265
    def __contains__(self, key):
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1266
        return key in self._map
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1267
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1268
    def __getitem__(self, key):
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1269
        return self._map[key]
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1270
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1271
    def keys(self):
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
  1272
        return self._map.keys()
34333
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
  1273
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1274
    def preload(self):
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1275
        """Loads the underlying data, if it's not already loaded"""
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1276
        self._map
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1277
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
  1278
    def addfile(self, f, oldstate, state, mode, size, mtime):
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1279
        """Add a tracked file to the dirstate."""
35835
bf367a93f000 dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents: 35086
diff changeset
  1280
        if oldstate in "?r" and r"_dirs" in self.__dict__:
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1281
            self._dirs.addpath(f)
35835
bf367a93f000 dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents: 35086
diff changeset
  1282
        if oldstate == "?" and r"_alldirs" in self.__dict__:
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1283
            self._alldirs.addpath(f)
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1284
        self._map[f] = dirstatetuple(state, mode, size, mtime)
35080
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
  1285
        if state != 'n' or mtime == -1:
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
  1286
            self.nonnormalset.add(f)
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
  1287
        if size == -2:
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
  1288
            self.otherparentset.add(f)
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1289
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
  1290
    def removefile(self, f, oldstate, size):
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1291
        """
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1292
        Mark a file as removed in the dirstate.
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1293
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1294
        The `size` parameter is used to store sentinel values that indicate
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1295
        the file's previous state.  In the future, we should refactor this
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1296
        to be more explicit about what that state is.
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1297
        """
35835
bf367a93f000 dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents: 35086
diff changeset
  1298
        if oldstate not in "?r" and r"_dirs" in self.__dict__:
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1299
            self._dirs.delpath(f)
35835
bf367a93f000 dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents: 35086
diff changeset
  1300
        if oldstate == "?" and r"_alldirs" in self.__dict__:
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1301
            self._alldirs.addpath(f)
35835
bf367a93f000 dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents: 35086
diff changeset
  1302
        if r"filefoldmap" in self.__dict__:
35082
e6c64744781f dirstate: move dropping of folded filenames into the dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35081
diff changeset
  1303
            normed = util.normcase(f)
e6c64744781f dirstate: move dropping of folded filenames into the dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35081
diff changeset
  1304
            self.filefoldmap.pop(normed, None)
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1305
        self._map[f] = dirstatetuple('r', 0, size, 0)
35080
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
  1306
        self.nonnormalset.add(f)
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1307
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
  1308
    def dropfile(self, f, oldstate):
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1309
        """
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1310
        Remove a file from the dirstate.  Returns True if the file was
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1311
        previously recorded.
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1312
        """
35080
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
  1313
        exists = self._map.pop(f, None) is not None
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
  1314
        if exists:
35835
bf367a93f000 dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents: 35086
diff changeset
  1315
            if oldstate != "r" and r"_dirs" in self.__dict__:
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1316
                self._dirs.delpath(f)
35835
bf367a93f000 dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents: 35086
diff changeset
  1317
            if r"_alldirs" in self.__dict__:
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1318
                self._alldirs.delpath(f)
35835
bf367a93f000 dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents: 35086
diff changeset
  1319
        if r"filefoldmap" in self.__dict__:
35082
e6c64744781f dirstate: move dropping of folded filenames into the dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35081
diff changeset
  1320
            normed = util.normcase(f)
e6c64744781f dirstate: move dropping of folded filenames into the dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35081
diff changeset
  1321
            self.filefoldmap.pop(normed, None)
35080
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
  1322
        self.nonnormalset.discard(f)
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
  1323
        return exists
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
  1324
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
  1325
    def clearambiguoustimes(self, files, now):
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
  1326
        for f in files:
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
  1327
            e = self.get(f)
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
  1328
            if e is not None and e[0] == 'n' and e[3] == now:
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
  1329
                self._map[f] = dirstatetuple(e[0], e[1], e[2], -1)
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
  1330
                self.nonnormalset.add(f)
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
  1331
34333
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
  1332
    def nonnormalentries(self):
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
  1333
        '''Compute the nonnormal dirstate entries from the dmap'''
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
  1334
        try:
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
  1335
            return parsers.nonnormalotherparententries(self._map)
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
  1336
        except AttributeError:
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
  1337
            nonnorm = set()
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
  1338
            otherparent = set()
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
  1339
            for fname, e in self._map.iteritems():
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
  1340
                if e[0] != 'n' or e[3] == -1:
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
  1341
                    nonnorm.add(fname)
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
  1342
                if e[0] == 'n' and e[2] == -2:
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
  1343
                    otherparent.add(fname)
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
  1344
            return nonnorm, otherparent
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
  1345
34676
bfddc3d678ae dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents: 34675
diff changeset
  1346
    @propertycache
34334
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1347
    def filefoldmap(self):
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1348
        """Returns a dictionary mapping normalized case paths to their
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1349
        non-normalized versions.
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1350
        """
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1351
        try:
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1352
            makefilefoldmap = parsers.make_file_foldmap
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1353
        except AttributeError:
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1354
            pass
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1355
        else:
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1356
            return makefilefoldmap(self._map, util.normcasespec,
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1357
                                   util.normcasefallback)
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1358
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1359
        f = {}
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1360
        normcase = util.normcase
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1361
        for name, s in self._map.iteritems():
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1362
            if s[0] != 'r':
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1363
                f[normcase(name)] = name
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1364
        f['.'] = '.' # prevents useless util.fspath() invocation
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
  1365
        return f
34335
af9722412ac3 dirstate: move _dirs to dirstatemap
Durham Goode <durham@fb.com>
parents: 34334
diff changeset
  1366
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1367
    def hastrackeddir(self, d):
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1368
        """
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1369
        Returns True if the dirstate contains a tracked (not removed) file
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1370
        in this directory.
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1371
        """
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1372
        return d in self._dirs
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1373
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1374
    def hasdir(self, d):
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1375
        """
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1376
        Returns True if the dirstate contains a file (tracked or removed)
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1377
        in this directory.
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1378
        """
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1379
        return d in self._alldirs
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1380
34677
014bd2a555c8 dirstate: remove _dirs property cache
Durham Goode <durham@fb.com>
parents: 34676
diff changeset
  1381
    @propertycache
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1382
    def _dirs(self):
34335
af9722412ac3 dirstate: move _dirs to dirstatemap
Durham Goode <durham@fb.com>
parents: 34334
diff changeset
  1383
        return util.dirs(self._map, 'r')
34337
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1384
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1385
    @propertycache
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1386
    def _alldirs(self):
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1387
        return util.dirs(self._map)
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1388
34337
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1389
    def _opendirstatefile(self):
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1390
        fp, mode = txnutil.trypending(self._root, self._opener, self._filename)
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1391
        if self._pendingmode is not None and self._pendingmode != mode:
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1392
            fp.close()
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1393
            raise error.Abort(_('working directory state may be '
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1394
                                'changed parallelly'))
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1395
        self._pendingmode = mode
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1396
        return fp
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
  1397
34338
0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class
Durham Goode <durham@fb.com>
parents: 34337
diff changeset
  1398
    def parents(self):
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1399
        if not self._parents:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1400
            try:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1401
                fp = self._opendirstatefile()
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1402
                st = fp.read(40)
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1403
                fp.close()
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1404
            except IOError as err:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1405
                if err.errno != errno.ENOENT:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1406
                    raise
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1407
                # File doesn't exist, so the current state is empty
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1408
                st = ''
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1409
34338
0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class
Durham Goode <durham@fb.com>
parents: 34337
diff changeset
  1410
            l = len(st)
0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class
Durham Goode <durham@fb.com>
parents: 34337
diff changeset
  1411
            if l == 40:
39422
adacefb0b7ea dirstate: use tuple interface to fix leak in pack_dirstate()
Yuya Nishihara <yuya@tcha.org>
parents: 36995
diff changeset
  1412
                self._parents = (st[:20], st[20:40])
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1413
            elif l == 0:
39422
adacefb0b7ea dirstate: use tuple interface to fix leak in pack_dirstate()
Yuya Nishihara <yuya@tcha.org>
parents: 36995
diff changeset
  1414
                self._parents = (nullid, nullid)
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1415
            else:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1416
                raise error.Abort(_('working directory state appears '
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1417
                                    'damaged!'))
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1418
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1419
        return self._parents
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1420
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1421
    def setparents(self, p1, p2):
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1422
        self._parents = (p1, p2)
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
  1423
        self._dirtyparents = True
34672
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1424
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1425
    def read(self):
34675
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
  1426
        # ignore HG_PENDING because identity is used only for writing
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
  1427
        self.identity = util.filestat.frompath(
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
  1428
            self._opener.join(self._filename))
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
  1429
34672
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1430
        try:
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1431
            fp = self._opendirstatefile()
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1432
            try:
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1433
                st = fp.read()
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1434
            finally:
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1435
                fp.close()
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1436
        except IOError as err:
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1437
            if err.errno != errno.ENOENT:
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1438
                raise
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1439
            return
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1440
        if not st:
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1441
            return
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1442
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1443
        if util.safehasattr(parsers, 'dict_new_presized'):
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1444
            # Make an estimate of the number of files in the dirstate based on
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1445
            # its size. From a linear regression on a set of real-world repos,
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1446
            # all over 10,000 files, the size of a dirstate entry is 85
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1447
            # bytes. The cost of resizing is significantly higher than the cost
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1448
            # of filling in a larger presized dict, so subtract 20% from the
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1449
            # size.
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1450
            #
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1451
            # This heuristic is imperfect in many ways, so in a future dirstate
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1452
            # format update it makes sense to just record the number of entries
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1453
            # on write.
36622
0297f9c4caee py3: do not pass a float to dict_new_presized()
Yuya Nishihara <yuya@tcha.org>
parents: 36200
diff changeset
  1454
            self._map = parsers.dict_new_presized(len(st) // 71)
34672
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1455
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1456
        # Python's garbage collector triggers a GC each time a certain number
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1457
        # of container objects (the number being defined by
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1458
        # gc.get_threshold()) are allocated. parse_dirstate creates a tuple
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1459
        # for each file in the dirstate. The C version then immediately marks
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1460
        # them as not to be tracked by the collector. However, this has no
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1461
        # effect on when GCs are triggered, only on what objects the GC looks
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1462
        # into. This means that O(number of files) GCs are unavoidable.
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1463
        # Depending on when in the process's lifetime the dirstate is parsed,
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1464
        # this can get very expensive. As a workaround, disable GC while
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1465
        # parsing the dirstate.
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1466
        #
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1467
        # (we cannot decorate the function directly since it is in a C module)
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1468
        parse_dirstate = util.nogc(parsers.parse_dirstate)
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1469
        p = parse_dirstate(self._map, self.copymap, st)
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1470
        if not self._dirtyparents:
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
  1471
            self.setparents(*p)
34673
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
  1472
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1473
        # Avoid excess attribute lookups by fast pathing certain checks
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1474
        self.__contains__ = self._map.__contains__
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1475
        self.__getitem__ = self._map.__getitem__
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1476
        self.get = self._map.get
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
  1477
34673
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
  1478
    def write(self, st, now):
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
  1479
        st.write(parsers.pack_dirstate(self._map, self.copymap,
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
  1480
                                       self.parents(), now))
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
  1481
        st.close()
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
  1482
        self._dirtyparents = False
34674
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
  1483
        self.nonnormalset, self.otherparentset = self.nonnormalentries()
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
  1484
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
  1485
    @propertycache
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
  1486
    def nonnormalset(self):
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
  1487
        nonnorm, otherparents = self.nonnormalentries()
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
  1488
        self.otherparentset = otherparents
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
  1489
        return nonnorm
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
  1490
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
  1491
    @propertycache
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
  1492
    def otherparentset(self):
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
  1493
        nonnorm, otherparents = self.nonnormalentries()
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
  1494
        self.nonnormalset = nonnorm
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
  1495
        return otherparents
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
  1496
34675
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
  1497
    @propertycache
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
  1498
    def identity(self):
34934
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
  1499
        self._map
34675
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
  1500
        return self.identity
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
  1501
34678
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
  1502
    @propertycache
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
  1503
    def dirfoldmap(self):
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
  1504
        f = {}
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
  1505
        normcase = util.normcase
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
  1506
        for name in self._dirs:
34678
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
  1507
            f[normcase(name)] = name
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
  1508
        return f