mercurial/dirstate.py
author Augie Fackler <augie@google.com>
Sun, 17 May 2015 21:12:33 -0400
changeset 25157 a8d22895a575
parent 25151 6eb4bdad198f
child 25163 3139900f31b1
permissions -rw-r--r--
run-tests: introduce PYTHON3 boolean constant (issue4668) This will avoid open-coding lots of version_info checks later in the file.
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
6211
f89fd07fc51d Expand import * to allow Pyflakes to find problems
Joel Rosdahl <joel@rosdahl.net>
parents: 6201
diff changeset
     8
from node import nullid
3891
6b4127c7d52a Simplify i18n imports
Matt Mackall <mpm@selenic.com>
parents: 3877
diff changeset
     9
from i18n import _
20033
f962870712da pathutil: tease out a new library to break an import cycle from canonpath use
Augie Fackler <raf@durin42.com>
parents: 19910
diff changeset
    10
import scmutil, util, ignore, osutil, parsers, encoding, pathutil
23496
ee5a4ed4c8b1 dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23375
diff changeset
    11
import os, stat, errno
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
    12
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    13
propertycache = util.propertycache
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    14
filecache = scmutil.filecache
17733
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents: 17197
diff changeset
    15
_rangemask = 0x7fffffff
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    16
21809
e250b8300e6e parsers: inline fields of dirstate values in C version
Siddharth Agarwal <sid0@fb.com>
parents: 21808
diff changeset
    17
dirstatetuple = parsers.dirstatetuple
21808
7537e57f5dbd dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents: 21116
diff changeset
    18
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    19
class repocache(filecache):
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    20
    """filecache for files in .hg/"""
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    21
    def join(self, obj, fname):
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    22
        return obj._opener.join(fname)
4610
274c99fc629f dirstate: simplify state()
Matt Mackall <mpm@selenic.com>
parents: 4609
diff changeset
    23
16202
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    24
class rootcache(filecache):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    25
    """filecache for files in the repository root"""
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    26
    def join(self, obj, fname):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    27
        return obj._join(fname)
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    28
1559
59b3639df0a9 Convert all classes to new-style classes by deriving them from object.
Eric Hopper <hopper@omnifarious.org>
parents: 1541
diff changeset
    29
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
    30
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 12907
diff changeset
    31
    def __init__(self, opener, ui, root, validate):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    32
        '''Create a new dirstate object.
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    33
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    34
        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
    35
        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
    36
        the dirstate.
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    37
        '''
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
    38
        self._opener = opener
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 12907
diff changeset
    39
        self._validate = validate
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
    40
        self._root = root
24198
3cc630be5f09 dirstate: make sure rootdir ends with directory separator (issue4557)
Yuya Nishihara <yuya@tcha.org>
parents: 23866
diff changeset
    41
        # 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
    42
        # 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
    43
        self._rootdir = pathutil.normasprefix(root)
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
    44
        self._dirty = False
4965
4106dde15aed Merge with crew
Matt Mackall <mpm@selenic.com>
parents: 4911 4953
diff changeset
    45
        self._dirtypl = False
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
    46
        self._lastnormaltime = 0
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
    47
        self._ui = ui
16200
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16143
diff changeset
    48
        self._filecache = {}
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    49
        self._parentwriters = 0
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    50
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    51
    def beginparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    52
        '''Marks the beginning of a set of changes that involve changing
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    53
        the dirstate parents. If there is an exception during this time,
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    54
        the dirstate will not be written when the wlock is released. This
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    55
        prevents writing an incoherent dirstate where the parent doesn't
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    56
        match the contents.
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    57
        '''
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    58
        self._parentwriters += 1
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    59
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    60
    def endparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    61
        '''Marks the end of a set of changes that involve changing the
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    62
        dirstate parents. Once all parent changes have been marked done,
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    63
        the wlock will be free to write the dirstate on release.
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    64
        '''
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    65
        if self._parentwriters > 0:
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    66
            self._parentwriters -= 1
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    67
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    68
    def pendingparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    69
        '''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
    70
        that modify the dirstate parent.
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    71
        '''
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
    72
        return self._parentwriters > 0
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
    73
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    74
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    75
    def _map(self):
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
    76
        '''Return the dirstate contents as a map from filename to
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
    77
        (state, mode, size, time).'''
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    78
        self._read()
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    79
        return self._map
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    80
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    81
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    82
    def _copymap(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    83
        self._read()
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    84
        return self._copymap
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    85
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    86
    @propertycache
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
    87
    def _filefoldmap(self):
24610
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
    88
        try:
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
    89
            makefilefoldmap = parsers.make_file_foldmap
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
    90
        except AttributeError:
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
    91
            pass
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
    92
        else:
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
    93
            return makefilefoldmap(self._map, util.normcasespec,
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
    94
                                   util.normcasefallback)
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
    95
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    96
        f = {}
22782
a1eb21f5caea dirstate: cache util.normcase while constructing the foldmap
Siddharth Agarwal <sid0@fb.com>
parents: 22459
diff changeset
    97
        normcase = util.normcase
19103
0176d0db4671 icasefs: ignore removed files at building "dirstate._foldmap" up on icasefs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18899
diff changeset
    98
        for name, s in self._map.iteritems():
0176d0db4671 icasefs: ignore removed files at building "dirstate._foldmap" up on icasefs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18899
diff changeset
    99
            if s[0] != 'r':
22782
a1eb21f5caea dirstate: cache util.normcase while constructing the foldmap
Siddharth Agarwal <sid0@fb.com>
parents: 22459
diff changeset
   100
                f[normcase(name)] = name
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   101
        f['.'] = '.' # prevents useless util.fspath() invocation
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   102
        return f
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   103
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   104
    @propertycache
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   105
    def _dirfoldmap(self):
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   106
        f = {}
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   107
        normcase = util.normcase
16302
49b54f1ae053 dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents: 16258
diff changeset
   108
        for name in self._dirs:
22782
a1eb21f5caea dirstate: cache util.normcase while constructing the foldmap
Siddharth Agarwal <sid0@fb.com>
parents: 22459
diff changeset
   109
            f[normcase(name)] = name
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   110
        return f
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   111
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
   112
    @repocache('branch')
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   113
    def _branch(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   114
        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
   115
            return self._opener.read("branch").strip() or "default"
15799
e43c140eb08f dirstate: propagate IOError other than ENOENT when reading branch
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15670
diff changeset
   116
        except IOError, inst:
e43c140eb08f dirstate: propagate IOError other than ENOENT when reading branch
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15670
diff changeset
   117
            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
   118
                raise
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   119
            return "default"
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   120
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   121
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   122
    def _pl(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   123
        try:
13400
14f3795a5ed7 explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 13343
diff changeset
   124
            fp = self._opener("dirstate")
14f3795a5ed7 explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 13343
diff changeset
   125
            st = fp.read(40)
14f3795a5ed7 explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 13343
diff changeset
   126
            fp.close()
8716
f3322bb29a0e dirstate: don't complain about 0-length files
Matt Mackall <mpm@selenic.com>
parents: 8708
diff changeset
   127
            l = len(st)
f3322bb29a0e dirstate: don't complain about 0-length files
Matt Mackall <mpm@selenic.com>
parents: 8708
diff changeset
   128
            if l == 40:
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   129
                return st[:20], st[20:40]
8716
f3322bb29a0e dirstate: don't complain about 0-length files
Matt Mackall <mpm@selenic.com>
parents: 8708
diff changeset
   130
            elif l > 0 and l < 40:
8640
8536119f2f94 dirstate: notice truncated parents read
Matt Mackall <mpm@selenic.com>
parents: 8589
diff changeset
   131
                raise util.Abort(_('working directory state appears damaged!'))
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   132
        except IOError, err:
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   133
            if err.errno != errno.ENOENT:
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   134
                raise
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   135
        return [nullid, nullid]
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   136
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   137
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   138
    def _dirs(self):
24635
21e1ece30f8c util: move dirs() and finddirs() from scmutil to util
Drew Gottlieb <drgott@google.com>
parents: 24632
diff changeset
   139
        return util.dirs(self._map, 'r')
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   140
16143
fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15801
diff changeset
   141
    def dirs(self):
fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15801
diff changeset
   142
        return self._dirs
fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15801
diff changeset
   143
16202
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
   144
    @rootcache('.hgignore')
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   145
    def _ignore(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   146
        files = [self._join('.hgignore')]
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   147
        for name, path in self._ui.configitems("ui"):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   148
            if name == 'ignore' or name.startswith('ignore.'):
23629
a04c7b74b3d5 ignore: resolve ignore files relative to repo root (issue4473) (BC)
Siddharth Agarwal <sid0@fb.com>
parents: 23496
diff changeset
   149
                # we need to use os.path.join here rather than self._join
a04c7b74b3d5 ignore: resolve ignore files relative to repo root (issue4473) (BC)
Siddharth Agarwal <sid0@fb.com>
parents: 23496
diff changeset
   150
                # because path is arbitrary and user-specified
a04c7b74b3d5 ignore: resolve ignore files relative to repo root (issue4473) (BC)
Siddharth Agarwal <sid0@fb.com>
parents: 23496
diff changeset
   151
                files.append(os.path.join(self._rootdir, util.expandpath(path)))
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   152
        return ignore.ignore(self._root, files, self._ui.warn)
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   153
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   154
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   155
    def _slash(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   156
        return self._ui.configbool('ui', 'slash') and os.sep != '/'
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   157
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   158
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   159
    def _checklink(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   160
        return util.checklink(self._root)
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   161
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   162
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   163
    def _checkexec(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   164
        return util.checkexec(self._root)
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   165
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   166
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   167
    def _checkcase(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   168
        return not util.checkcase(self._join('.hg'))
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   169
4905
fc61495ea9cf dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents: 4904
diff changeset
   170
    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
   171
        # 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
   172
        # 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
   173
        return self._rootdir + f
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
   174
15337
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   175
    def flagfunc(self, buildfallback):
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   176
        if self._checklink and self._checkexec:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   177
            def f(x):
18869
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   178
                try:
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   179
                    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
   180
                    if util.statislink(st):
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   181
                        return 'l'
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   182
                    if util.statisexec(st):
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   183
                        return 'x'
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   184
                except OSError:
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   185
                    pass
15337
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   186
                return ''
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   187
            return f
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   188
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   189
        fallback = buildfallback()
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   190
        if self._checklink:
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   191
            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
   192
                if os.path.islink(self._join(x)):
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   193
                    return 'l'
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   194
                if 'x' in fallback(x):
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   195
                    return 'x'
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   196
                return ''
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   197
            return f
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   198
        if self._checkexec:
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   199
            def f(x):
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   200
                if 'l' in fallback(x):
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   201
                    return 'l'
14273
38af0f514134 rename util.is_exec to isexec
Adrian Buehlmann <adrian@cadifra.com>
parents: 14168
diff changeset
   202
                if util.isexec(self._join(x)):
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   203
                    return 'x'
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   204
                return ''
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   205
            return f
15337
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   206
        else:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   207
            return fallback
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   208
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
   209
    @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
   210
    def _cwd(self):
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
        return os.getcwd()
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
870
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
   213
    def getcwd(self):
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
   214
        cwd = self._cwd
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   215
        if cwd == self._root:
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   216
            return ''
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   217
        # 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
   218
        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
   219
        if not util.endswithsep(rootsep):
4230
c93562fb12cc Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4229
diff changeset
   220
            rootsep += os.sep
c93562fb12cc Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4229
diff changeset
   221
        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
   222
            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
   223
        else:
c93562fb12cc Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4229
diff changeset
   224
            # 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
   225
            return cwd
870
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
   226
4525
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4507
diff changeset
   227
    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
   228
        if cwd is None:
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4507
diff changeset
   229
            cwd = self.getcwd()
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   230
        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
   231
        if self._slash:
19210
865beb849720 dirstate: don't overnormalize for ui.slash
Matt Mackall <mpm@selenic.com>
parents: 19128
diff changeset
   232
            return util.pconvert(path)
4527
b422b558015b Add ui.slash hgrc setting
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4525
diff changeset
   233
        return path
4525
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4507
diff changeset
   234
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   235
    def __getitem__(self, key):
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   236
        '''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
   237
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   238
        States are:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   239
          n  normal
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   240
          m  needs merging
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   241
          r  marked for removal
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   242
          a  marked for addition
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   243
          ?  not tracked
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   244
        '''
4906
30847b8af7ca dirstate: add __contains__ and make __getitem__ more useful
Matt Mackall <mpm@selenic.com>
parents: 4905
diff changeset
   245
        return self._map.get(key, ("?",))[0]
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
   246
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
   247
    def __contains__(self, key):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   248
        return key in self._map
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   249
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   250
    def __iter__(self):
8209
a1a5a57efe90 replace util.sort with sorted built-in
Matt Mackall <mpm@selenic.com>
parents: 8151
diff changeset
   251
        for x in sorted(self._map):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   252
            yield x
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
   253
18792
10669e24eb6c completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents: 18760
diff changeset
   254
    def iteritems(self):
10669e24eb6c completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents: 18760
diff changeset
   255
        return self._map.iteritems()
10669e24eb6c completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents: 18760
diff changeset
   256
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
   257
    def parents(self):
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 12907
diff changeset
   258
        return [self._validate(p) for p in self._pl]
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
   259
13876
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   260
    def p1(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   261
        return self._validate(self._pl[0])
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   262
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   263
    def p2(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   264
        return self._validate(self._pl[1])
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   265
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
   266
    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
   267
        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
   268
1062
6d5a62a549fa pep-0008 cleanup
benoit.boissinot@ens-lyon.fr
parents: 1040
diff changeset
   269
    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
   270
        """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
   271
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   272
        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
   273
        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
   274
        returned by the call.
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   275
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   276
        See localrepo.setparents()
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   277
        """
22407
d259322a394b dirstate: add exception when calling setparent without begin/end (API)
Durham Goode <durham@fb.com>
parents: 22404
diff changeset
   278
        if self._parentwriters == 0:
22459
0c7b018d3258 dirstate: copyedit exception for no beginparentchange call
Siddharth Agarwal <sid0@fb.com>
parents: 22407
diff changeset
   279
            raise ValueError("cannot set dirstate parent without "
0c7b018d3258 dirstate: copyedit exception for no beginparentchange call
Siddharth Agarwal <sid0@fb.com>
parents: 22407
diff changeset
   280
                             "calling dirstate.beginparentchange")
22407
d259322a394b dirstate: add exception when calling setparent without begin/end (API)
Durham Goode <durham@fb.com>
parents: 22404
diff changeset
   281
4965
4106dde15aed Merge with crew
Matt Mackall <mpm@selenic.com>
parents: 4911 4953
diff changeset
   282
        self._dirty = self._dirtypl = True
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   283
        oldp2 = self._pl[1]
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   284
        self._pl = p1, p2
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   285
        copies = {}
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   286
        if oldp2 != nullid and p2 == nullid:
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   287
            for f, s in self._map.iteritems():
22895
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
   288
                # 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
   289
                if s[0] == 'm':
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   290
                    if f in self._copymap:
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   291
                        copies[f] = self._copymap[f]
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   292
                    self.normallookup(f)
22895
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
   293
                # 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
   294
                elif s[0] == 'n' and s[2] == -2:
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
   295
                    if f in self._copymap:
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
   296
                        copies[f] = self._copymap[f]
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
   297
                    self.add(f)
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   298
        return copies
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
   299
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
   300
    def setbranch(self, branch):
13047
6c375e07d673 branch: operate on branch names in local string space where possible
Matt Mackall <mpm@selenic.com>
parents: 13032
diff changeset
   301
        self._branch = encoding.fromlocal(branch)
16472
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   302
        f = self._opener('branch', 'w', atomictemp=True)
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   303
        try:
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   304
            f.write(self._branch + '\n')
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   305
            f.close()
18317
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   306
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   307
            # 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
   308
            # replacing the underlying file
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   309
            ce = self._filecache['_branch']
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   310
            if ce:
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   311
                ce.refresh()
18076
3bc21f6daac4 dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents: 17984
diff changeset
   312
        except: # re-raises
3bc21f6daac4 dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents: 17984
diff changeset
   313
            f.discard()
3bc21f6daac4 dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents: 17984
diff changeset
   314
            raise
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
   315
4615
9b00b73a5286 dirstate: hide some more internals
Matt Mackall <mpm@selenic.com>
parents: 4614
diff changeset
   316
    def _read(self):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   317
        self._map = {}
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   318
        self._copymap = {}
4607
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   319
        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
   320
            st = self._opener.read("dirstate")
4607
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   321
        except IOError, err:
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   322
            if err.errno != errno.ENOENT:
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   323
                raise
4607
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   324
            return
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   325
        if not st:
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   326
            return
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   327
18649
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   328
        # Python's garbage collector triggers a GC each time a certain number
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   329
        # of container objects (the number being defined by
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   330
        # gc.get_threshold()) are allocated. parse_dirstate creates a tuple
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   331
        # for each file in the dirstate. The C version then immediately marks
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   332
        # them as not to be tracked by the collector. However, this has no
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   333
        # effect on when GCs are triggered, only on what objects the GC looks
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   334
        # into. This means that O(number of files) GCs are unavoidable.
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   335
        # Depending on when in the process's lifetime the dirstate is parsed,
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   336
        # this can get very expensive. As a workaround, disable GC while
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   337
        # parsing the dirstate.
23496
ee5a4ed4c8b1 dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23375
diff changeset
   338
        #
ee5a4ed4c8b1 dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23375
diff changeset
   339
        # (we cannot decorate the function directly since it is in a C module)
ee5a4ed4c8b1 dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23375
diff changeset
   340
        parse_dirstate = util.nogc(parsers.parse_dirstate)
ee5a4ed4c8b1 dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23375
diff changeset
   341
        p = parse_dirstate(self._map, self._copymap, st)
4952
a11921d24ec4 add dirstate._dirtypl variable
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4677
diff changeset
   342
        if not self._dirtypl:
7093
16bafcebd3d1 dirstate: C parsing extension
Matt Mackall <mpm@selenic.com>
parents: 7069
diff changeset
   343
            self._pl = p
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
   344
4613
3a645af7fb76 localrepo and dirstate: rename reload to invalidate
Matt Mackall <mpm@selenic.com>
parents: 4612
diff changeset
   345
    def invalidate(self):
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   346
        for a in ("_map", "_copymap", "_filefoldmap", "_dirfoldmap", "_branch",
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   347
                  "_pl", "_dirs", "_ignore"):
4953
6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4952
diff changeset
   348
            if a in self.__dict__:
6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4952
diff changeset
   349
                delattr(self, a)
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
   350
        self._lastnormaltime = 0
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
   351
        self._dirty = False
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   352
        self._parentwriters = 0
4375
109077e7048d When reloading the dirstate, recompute ignore information if needed.
Bryan O'Sullivan <bos@serpentine.com>
parents: 4374
diff changeset
   353
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
   354
    def copy(self, source, dest):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   355
        """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
   356
        if source == dest:
deda205a00e1 Ignore dummy copies in dirstate and localrepo.filecommit()
Patrick Mezard <pmezard@gmail.com>
parents: 6479
diff changeset
   357
            return
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
   358
        self._dirty = True
7566
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents: 7280
diff changeset
   359
        if source is not None:
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents: 7280
diff changeset
   360
            self._copymap[dest] = source
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents: 7280
diff changeset
   361
        elif dest in self._copymap:
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents: 7280
diff changeset
   362
            del self._copymap[dest]
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
   363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
   364
    def copied(self, file):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   365
        return self._copymap.get(file, None)
3154
b1f10d3223c1 dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents: 2962
diff changeset
   366
b1f10d3223c1 dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents: 2962
diff changeset
   367
    def copies(self):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   368
        return self._copymap
515
03f27b1381f9 Whitespace cleanups
mpm@selenic.com
parents: 514
diff changeset
   369
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   370
    def _droppath(self, f):
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   371
        if self[f] not in "?r" and "_dirs" in self.__dict__:
18899
d8ff607ef721 scmutil: use new dirs class in dirstate and context
Bryan O'Sullivan <bryano@fb.com>
parents: 18897
diff changeset
   372
            self._dirs.delpath(f)
2953
3d5547845158 fix issue 322.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2859
diff changeset
   373
17196
2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents: 17094
diff changeset
   374
    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
   375
        oldstate = self[f]
17196
2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents: 17094
diff changeset
   376
        if state == 'a' or oldstate == 'r':
13974
23f2736abce3 move checkfilename from util to scmutil
Adrian Buehlmann <adrian@cadifra.com>
parents: 13944
diff changeset
   377
            scmutil.checkfilename(f)
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   378
            if f in self._dirs:
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   379
                raise util.Abort(_('directory %r already in dirstate') % f)
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):
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   382
                if d in self._dirs:
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   383
                    break
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   384
                if d in self._map and self[d] != 'r':
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   385
                    raise util.Abort(
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   386
                        _('file %r in dirstate clashes with %r') % (d, f))
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   387
        if oldstate in "?r" and "_dirs" in self.__dict__:
18899
d8ff607ef721 scmutil: use new dirs class in dirstate and context
Bryan O'Sullivan <bryano@fb.com>
parents: 18897
diff changeset
   388
            self._dirs.addpath(f)
17094
c2016bae3b97 dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents: 16955
diff changeset
   389
        self._dirty = True
21808
7537e57f5dbd dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents: 21116
diff changeset
   390
        self._map[f] = dirstatetuple(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
   391
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   392
    def normal(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   393
        '''Mark a file normal and clean.'''
4905
fc61495ea9cf dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents: 4904
diff changeset
   394
        s = os.lstat(self._join(f))
13754
ae157ca56cd5 dirstate: check mtime when adding to _lastnormal
Adrian Buehlmann <adrian@cadifra.com>
parents: 13743
diff changeset
   395
        mtime = int(s.st_mtime)
17733
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents: 17197
diff changeset
   396
        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
   397
                      s.st_size & _rangemask, mtime & _rangemask)
5915
d0576d065993 Prefer i in d over d.has_key(i)
Christian Ebert <blacktrash@gmx.net>
parents: 5843
diff changeset
   398
        if f in self._copymap:
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   399
            del self._copymap[f]
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   400
        if mtime > self._lastnormaltime:
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   401
            # 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
   402
            # 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
   403
            # modifications that happen within the same timeslot.
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   404
            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
   405
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
   406
    def normallookup(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   407
        '''Mark a file normal, but possibly dirty.'''
6298
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   408
        if self._pl[1] != nullid and f in self._map:
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   409
            # 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
   410
            # 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
   411
            # being removed, restore that state.
6298
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   412
            entry = self._map[f]
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   413
            if entry[0] == 'r' and entry[2] in (-1, -2):
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   414
                source = self._copymap.get(f)
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   415
                if entry[2] == -1:
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   416
                    self.merge(f)
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   417
                elif entry[2] == -2:
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   418
                    self.otherparent(f)
6298
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   419
                if source:
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   420
                    self.copy(source, f)
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   421
                return
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   422
            if entry[0] == 'm' or entry[0] == 'n' and entry[2] == -2:
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   423
                return
17094
c2016bae3b97 dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents: 16955
diff changeset
   424
        self._addpath(f, 'n', 0, -1, -1)
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
   425
        if f in self._copymap:
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
   426
            del self._copymap[f]
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
   427
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   428
    def otherparent(self, f):
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   429
        '''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
   430
        if self._pl[1] == nullid:
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   431
            raise util.Abort(_("setting %r to other parent "
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   432
                               "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
   433
        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
   434
            # merge-like
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   435
            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
   436
        else:
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   437
            # add-like
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   438
            self._addpath(f, 'n', 0, -2, -1)
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   439
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   440
        if f in self._copymap:
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   441
            del self._copymap[f]
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)
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   446
        if f in self._copymap:
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   447
            del self._copymap[f]
4616
70352337934e dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents: 4615
diff changeset
   448
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   449
    def remove(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   450
        '''Mark a file removed.'''
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   451
        self._dirty = True
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   452
        self._droppath(f)
6297
fed1a9c22076 dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6257
diff changeset
   453
        size = 0
fed1a9c22076 dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6257
diff changeset
   454
        if self._pl[1] != nullid and f in self._map:
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   455
            # backup the previous state
6297
fed1a9c22076 dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6257
diff changeset
   456
            entry = self._map[f]
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   457
            if entry[0] == 'm': # merge
6297
fed1a9c22076 dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6257
diff changeset
   458
                size = -1
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   459
            elif entry[0] == 'n' and entry[2] == -2: # other parent
6297
fed1a9c22076 dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6257
diff changeset
   460
                size = -2
21808
7537e57f5dbd dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents: 21116
diff changeset
   461
        self._map[f] = dirstatetuple('r', 0, size, 0)
6297
fed1a9c22076 dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6257
diff changeset
   462
        if size == 0 and f in self._copymap:
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   463
            del self._copymap[f]
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   464
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   465
    def merge(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   466
        '''Mark a file merged.'''
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   467
        if self._pl[1] == nullid:
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   468
            return self.normallookup(f)
22897
8fe74328f700 dirstate: merge falls through to otherparent
Matt Mackall <mpm@selenic.com>
parents: 22896
diff changeset
   469
        return self.otherparent(f)
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   470
14434
cc8c09855d19 dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents: 14273
diff changeset
   471
    def drop(self, f):
cc8c09855d19 dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents: 14273
diff changeset
   472
        '''Drop a file from the dirstate'''
15399
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents: 15337
diff changeset
   473
        if f in self._map:
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents: 15337
diff changeset
   474
            self._dirty = True
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents: 15337
diff changeset
   475
            self._droppath(f)
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents: 15337
diff changeset
   476
            del self._map[f]
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   477
24538
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   478
    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
   479
        if exists is None:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   480
            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
   481
        if not exists:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   482
            # Maybe a path component exists
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   483
            if not ignoremissing and '/' in path:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   484
                d, f = path.rsplit('/', 1)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   485
                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
   486
                folded = d + "/" + f
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   487
            else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   488
                # No path components, preserve original case
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   489
                folded = path
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
            # recursively normalize leading directory components
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   492
            # against dirstate
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   493
            if '/' in normed:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   494
                d, f = normed.rsplit('/', 1)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   495
                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
   496
                r = self._root + "/" + d
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   497
                folded = d + "/" + util.fspath(f, r)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   498
            else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   499
                folded = util.fspath(normed, self._root)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   500
            storemap[normed] = folded
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   501
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   502
        return folded
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   503
24539
3a8eba78803e dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents: 24538
diff changeset
   504
    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
   505
        normed = util.normcase(path)
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   506
        folded = self._filefoldmap.get(normed, None)
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   507
        if folded is None:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   508
            if isknown:
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   509
                folded = path
7068
57377fa7eda2 issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents: 7034
diff changeset
   510
            else:
24539
3a8eba78803e dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents: 24538
diff changeset
   511
                folded = self._discoverpath(path, normed, ignoremissing, exists,
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   512
                                            self._filefoldmap)
24539
3a8eba78803e dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents: 24538
diff changeset
   513
        return folded
16302
49b54f1ae053 dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents: 16258
diff changeset
   514
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   515
    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
   516
        normed = util.normcase(path)
24561
6514030dc686 dirstate._normalize: don't construct dirfoldmap if not necessary
Siddharth Agarwal <sid0@fb.com>
parents: 24560
diff changeset
   517
        folded = self._filefoldmap.get(normed, None)
6514030dc686 dirstate._normalize: don't construct dirfoldmap if not necessary
Siddharth Agarwal <sid0@fb.com>
parents: 24560
diff changeset
   518
        if folded is None:
6514030dc686 dirstate._normalize: don't construct dirfoldmap if not necessary
Siddharth Agarwal <sid0@fb.com>
parents: 24560
diff changeset
   519
            folded = self._dirfoldmap.get(normed, None)
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   520
        if folded is None:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   521
            if isknown:
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   522
                folded = path
7068
57377fa7eda2 issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents: 7034
diff changeset
   523
            else:
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   524
                # 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
   525
                # 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
   526
                folded = self._discoverpath(path, normed, ignoremissing, exists,
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   527
                                            self._dirfoldmap)
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   528
        return folded
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   529
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   530
    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
   531
        '''
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   532
        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
   533
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   534
        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
   535
        disk, to avoid extra filesystem access.
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   536
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   537
        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
   538
        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
   539
        existing path components.
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   540
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   541
        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
   542
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   543
        - 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
   544
        - version of name stored on disk
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   545
        - version provided via command arguments
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   546
        '''
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   547
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   548
        if self._checkcase:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   549
            return self._normalize(path, isknown, ignoremissing)
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   550
        return path
6677
9865e15febd0 Add a normalize() method to dirstate
Paul Moore <p.f.moore@gmail.com>
parents: 6675
diff changeset
   551
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   552
    def clear(self):
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   553
        self._map = {}
5487
7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660).
Maxim Dounin <mdounin@mdounin.ru>
parents: 5396
diff changeset
   554
        if "_dirs" in self.__dict__:
10394
4612cded5176 fix coding style (reported by pylint)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10282
diff changeset
   555
            delattr(self, "_dirs")
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   556
        self._copymap = {}
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   557
        self._pl = [nullid, nullid]
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
   558
        self._lastnormaltime = 0
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):
e74704c33e24 strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents: 18663
diff changeset
   562
        changedfiles = changedfiles or allfiles
e74704c33e24 strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents: 18663
diff changeset
   563
        oldmap = self._map
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   564
        self.clear()
18760
e74704c33e24 strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents: 18663
diff changeset
   565
        for f in allfiles:
e74704c33e24 strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents: 18663
diff changeset
   566
            if f not in changedfiles:
e74704c33e24 strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents: 18663
diff changeset
   567
                self._map[f] = oldmap[f]
1755
a8f7791e3680 add 'debugrebuildstate' to rebuild the dirstate from a given revision
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1749
diff changeset
   568
            else:
18760
e74704c33e24 strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents: 18663
diff changeset
   569
                if 'x' in allfiles.flags(f):
21808
7537e57f5dbd dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents: 21116
diff changeset
   570
                    self._map[f] = dirstatetuple('n', 0777, -1, 0)
18760
e74704c33e24 strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents: 18663
diff changeset
   571
                else:
21808
7537e57f5dbd dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents: 21116
diff changeset
   572
                    self._map[f] = dirstatetuple('n', 0666, -1, 0)
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   573
        self._pl = (parent, nullid)
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
   574
        self._dirty = True
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   575
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   576
    def write(self):
4612
17ee7407097f dirstate: simplify dirty handling
Matt Mackall <mpm@selenic.com>
parents: 4611
diff changeset
   577
        if not self._dirty:
1794
98b6c1cad58b only write the dirstate when something changed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1755
diff changeset
   578
            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
   579
89b809fa6cef dirstate: delay writing out to ensure timestamp of each entries explicitly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 21810
diff changeset
   580
        # enough 'delaywrite' prevents 'pack_dirstate' from dropping
89b809fa6cef dirstate: delay writing out to ensure timestamp of each entries explicitly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 21810
diff changeset
   581
        # timestamp of each entries in dirstate, because of 'now > mtime'
89b809fa6cef dirstate: delay writing out to ensure timestamp of each entries explicitly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 21810
diff changeset
   582
        delaywrite = self._ui.configint('debug', 'dirstate.delaywrite', 0)
23866
9dd442148301 dirstate: ignore negative debug.dirstate.delaywrite values - they crashed it
Mads Kiilerich <madski@unity3d.com>
parents: 23629
diff changeset
   583
        if delaywrite > 0:
21931
89b809fa6cef dirstate: delay writing out to ensure timestamp of each entries explicitly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 21810
diff changeset
   584
            import time # to avoid useless import
89b809fa6cef dirstate: delay writing out to ensure timestamp of each entries explicitly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 21810
diff changeset
   585
            time.sleep(delaywrite)
89b809fa6cef dirstate: delay writing out to ensure timestamp of each entries explicitly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 21810
diff changeset
   586
6326
af3f26b6bba4 dirstate: ignore stat data for files that were updated too recently
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6298
diff changeset
   587
        st = self._opener("dirstate", "w", atomictemp=True)
9509
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   588
        # 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
   589
        # filesystem's notion of 'now'
16955
92e1c64ba0d4 parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents: 16686
diff changeset
   590
        now = util.fstat(st).st_mtime
21026
7ee03e190c1d dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents: 20632
diff changeset
   591
        st.write(parsers.pack_dirstate(self._map, self._copymap, self._pl, now))
7ee03e190c1d dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents: 20632
diff changeset
   592
        st.close()
7ee03e190c1d dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents: 20632
diff changeset
   593
        self._lastnormaltime = 0
7ee03e190c1d dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents: 20632
diff changeset
   594
        self._dirty = self._dirtypl = False
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   595
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   596
    def _dirignore(self, f):
6479
31abcae33b4f dirstate: do not ignore current directory '.' (issue 1078)
Patrick Mezard <pmezard@gmail.com>
parents: 6327
diff changeset
   597
        if f == '.':
31abcae33b4f dirstate: do not ignore current directory '.' (issue 1078)
Patrick Mezard <pmezard@gmail.com>
parents: 6327
diff changeset
   598
            return False
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   599
        if self._ignore(f):
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   600
            return True
24635
21e1ece30f8c util: move dirs() and finddirs() from scmutil to util
Drew Gottlieb <drgott@google.com>
parents: 24632
diff changeset
   601
        for p in util.finddirs(f):
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   602
            if self._ignore(p):
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   603
                return True
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   604
        return False
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   605
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   606
    def _walkexplicit(self, match, subrepos):
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   607
        '''Get stat data about the files explicitly specified by match.
3529
09d99b7e4da0 simplify dirstate walking
Matt Mackall <mpm@selenic.com>
parents: 3223
diff changeset
   608
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   609
        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
   610
        - 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
   611
          listings mapping subrepos and .hg to None.
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   612
        - 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
   613
        - 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
   614
          directories and that were not found.'''
6578
f242d3684f83 walk: begin refactoring badmatch handling
Matt Mackall <mpm@selenic.com>
parents: 6577
diff changeset
   615
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
   616
        def badtype(mode):
8310
8417d82d3969 dirstate: translate forgotten string
Simon Heimberg <simohe@besonet.ch>
parents: 8261
diff changeset
   617
            kind = _('unknown')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   618
            if stat.S_ISCHR(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   619
                kind = _('character device')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   620
            elif stat.S_ISBLK(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   621
                kind = _('block device')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   622
            elif stat.S_ISFIFO(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   623
                kind = _('fifo')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   624
            elif stat.S_ISSOCK(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   625
                kind = _('socket')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   626
            elif stat.S_ISDIR(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   627
                kind = _('directory')
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
   628
            return _('unsupported file type (type is %s)') % kind
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   629
19142
c3d3e4d75ec3 dirstate.walk: cache match.explicitdir and traversedir locally
Siddharth Agarwal <sid0@fb.com>
parents: 19137
diff changeset
   630
        matchedir = match.explicitdir
8676
acd69fc201a5 walk: we always have a badfn
Matt Mackall <mpm@selenic.com>
parents: 8675
diff changeset
   631
        badfn = match.bad
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   632
        dmap = self._map
5000
46facb73ba8b dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents: 4965
diff changeset
   633
        lstat = os.lstat
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   634
        getkind = stat.S_IFMT
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
   635
        dirkind = stat.S_IFDIR
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   636
        regkind = stat.S_IFREG
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   637
        lnkkind = stat.S_IFLNK
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   638
        join = self._join
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   639
        dirsfound = []
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   640
        foundadd = dirsfound.append
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   641
        dirsnotfound = []
19175
63f7bd2e1a46 dirstate._walkexplicit: inline dirsnotfound.append
Siddharth Agarwal <sid0@fb.com>
parents: 19174
diff changeset
   642
        notfoundadd = dirsnotfound.append
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   643
24448
55c449345b10 match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents: 24212
diff changeset
   644
        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
   645
            normalize = self._normalize
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
   646
        else:
18032
a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents: 18018
diff changeset
   647
            normalize = None
12907
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
   648
12211
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   649
        files = sorted(match.files())
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   650
        subrepos.sort()
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   651
        i, j = 0, 0
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   652
        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
   653
            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
   654
            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
   655
                i += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   656
                continue
13339
22167be007ed subrepo: fix pruning of subrepo filenames in dirstate (issue2619)
trbs <trbs@trbs.net>
parents: 13233
diff changeset
   657
            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
   658
                del files[i]
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   659
            j += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   660
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   661
        if not files or '.' in files:
24521
489026bffbf6 dirstate._walkexplicit: indicate root as '.', not ''
Siddharth Agarwal <sid0@fb.com>
parents: 24448
diff changeset
   662
            files = ['.']
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
   663
        results = dict.fromkeys(subrepos)
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
   664
        results['.hg'] = None
5000
46facb73ba8b dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents: 4965
diff changeset
   665
23375
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
   666
        alldirs = None
12211
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   667
        for ff in files:
24523
a4b81dbe73c1 dirstate._walkexplicit: don't bother normalizing '.'
Siddharth Agarwal <sid0@fb.com>
parents: 24522
diff changeset
   668
            # 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
   669
            # common case where files is ['.']
a4b81dbe73c1 dirstate._walkexplicit: don't bother normalizing '.'
Siddharth Agarwal <sid0@fb.com>
parents: 24522
diff changeset
   670
            if normalize and ff != '.':
24522
18085e46caa9 dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents: 24521
diff changeset
   671
                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
   672
            else:
24522
18085e46caa9 dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents: 24521
diff changeset
   673
                nf = ff
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
   674
            if nf in results:
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   675
                continue
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   676
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   677
            try:
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   678
                st = lstat(join(nf))
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   679
                kind = getkind(st.st_mode)
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   680
                if kind == dirkind:
8588
2624f485b9bc dirstate: set more states in step 1 of walk
Simon Heimberg <simohe@besonet.ch>
parents: 8521
diff changeset
   681
                    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
   682
                        # 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
   683
                        results[nf] = None
19143
3cb9468535bd match: make explicitdir and traversedir None by default
Siddharth Agarwal <sid0@fb.com>
parents: 19142
diff changeset
   684
                    if matchedir:
3cb9468535bd match: make explicitdir and traversedir None by default
Siddharth Agarwal <sid0@fb.com>
parents: 19142
diff changeset
   685
                        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
   686
                    foundadd((nf, ff))
12401
4cdaf1adafc8 backout most of 4f8067c94729
Matt Mackall <mpm@selenic.com>
parents: 12387
diff changeset
   687
                elif kind == regkind or kind == lnkkind:
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   688
                    results[nf] = st
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
   689
                else:
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
   690
                    badfn(ff, badtype(kind))
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   691
                    if nf in dmap:
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
   692
                        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
   693
            except OSError, inst: # nf not found on disk - it is dirstate only
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   694
                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
   695
                    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
   696
                else: # does it match a missing directory?
23375
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
   697
                    if alldirs is None:
24635
21e1ece30f8c util: move dirs() and finddirs() from scmutil to util
Drew Gottlieb <drgott@google.com>
parents: 24632
diff changeset
   698
                        alldirs = util.dirs(dmap)
23375
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
   699
                    if nf in alldirs:
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
   700
                        if matchedir:
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
   701
                            matchedir(nf)
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
   702
                        notfoundadd(nf)
8677
34df078b8b1b walk: simplify logic for badfn clause
Matt Mackall <mpm@selenic.com>
parents: 8676
diff changeset
   703
                    else:
8680
b6511055d37b match: ignore return of match.bad
Matt Mackall <mpm@selenic.com>
parents: 8677
diff changeset
   704
                        badfn(ff, inst.strerror)
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   705
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   706
        return results, dirsfound, dirsnotfound
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   707
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
   708
    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
   709
        '''
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   710
        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
   711
        matched by match.
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   712
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
   713
        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
   714
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   715
        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
   716
        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
   717
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   718
        '''
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
   719
        # 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
   720
        # 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
   721
        # 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
   722
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   723
        if ignored:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   724
            ignore = util.never
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   725
            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
   726
        elif unknown:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   727
            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
   728
            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
   729
        else:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   730
            # 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
   731
            ignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   732
            dirignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   733
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   734
        matchfn = match.matchfn
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   735
        matchalways = match.always()
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   736
        matchtdir = match.traversedir
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   737
        dmap = self._map
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   738
        listdir = osutil.listdir
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   739
        lstat = os.lstat
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   740
        dirkind = stat.S_IFDIR
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   741
        regkind = stat.S_IFREG
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   742
        lnkkind = stat.S_IFLNK
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   743
        join = self._join
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   744
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   745
        exact = skipstep3 = False
24448
55c449345b10 match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents: 24212
diff changeset
   746
        if match.isexact(): # match.exact
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   747
            exact = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   748
            dirignore = util.always # skip step 2
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   749
        elif match.files() and not match.anypats(): # match.match, no patterns
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   750
            skipstep3 = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   751
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   752
        if not exact and self._checkcase:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   753
            normalize = self._normalize
24541
e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents: 24540
diff changeset
   754
            normalizefile = self._normalizefile
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   755
            skipstep3 = False
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   756
        else:
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   757
            normalize = self._normalize
24541
e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents: 24540
diff changeset
   758
            normalizefile = None
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   759
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   760
        # step 1: find all explicit files
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   761
        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
   762
19172
c6cea2e2031b dirstate.walk: pull skipstep3 out of the explicit walk code
Siddharth Agarwal <sid0@fb.com>
parents: 19171
diff changeset
   763
        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
   764
        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
   765
6826
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents: 6825
diff changeset
   766
        # 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
   767
        def traverse(work, alreadynormed):
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   768
            wadd = work.append
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   769
            while work:
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   770
                nd = work.pop()
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   771
                skip = None
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   772
                if nd == '.':
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   773
                    nd = ''
18032
a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents: 18018
diff changeset
   774
                else:
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   775
                    skip = '.hg'
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   776
                try:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   777
                    entries = listdir(join(nd), stat=True, skip=skip)
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   778
                except OSError, inst:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   779
                    if inst.errno in (errno.EACCES, errno.ENOENT):
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   780
                        match.bad(self.pathto(nd), inst.strerror)
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   781
                        continue
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   782
                    raise
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   783
                for f, kind, st in entries:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   784
                    if normalizefile:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   785
                        # 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
   786
                        # 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
   787
                        # dmap -- therefore normalizefile is enough
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   788
                        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
   789
                                           True)
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   790
                    else:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   791
                        nf = nd and (nd + "/" + f) or f
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   792
                    if nf not in results:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   793
                        if kind == dirkind:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   794
                            if not ignore(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   795
                                if matchtdir:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   796
                                    matchtdir(nf)
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   797
                                wadd(nf)
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   798
                            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
   799
                                results[nf] = None
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   800
                        elif kind == regkind or kind == lnkkind:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   801
                            if nf in dmap:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   802
                                if matchalways or matchfn(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   803
                                    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
   804
                            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
   805
                                  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
   806
                                # 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
   807
                                if not alreadynormed:
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   808
                                    nf = normalize(nf, False, True)
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   809
                                results[nf] = st
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   810
                        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
   811
                            results[nf] = None
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   812
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   813
        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
   814
            # 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
   815
            # expensive directory normalization
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   816
            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
   817
            traverse([d], alreadynormed)
536
c15b4bc0a11c Refactor diffrevs/diffdir into changes
mpm@selenic.com
parents: 529
diff changeset
   818
18812
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18792
diff changeset
   819
        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
   820
            del results[s]
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18792
diff changeset
   821
        del results['.hg']
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18792
diff changeset
   822
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   823
        # 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
   824
        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
   825
            # 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
   826
            # 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
   827
            # 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
   828
            if not results and matchalways:
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
   829
                visit = dmap.keys()
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
   830
            else:
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
   831
                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
   832
            visit.sort()
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
   833
18625
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
   834
            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
   835
                # 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
   836
                # 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
   837
                # 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
   838
                # The rest must thus be ignored or under a symlink.
20033
f962870712da pathutil: tease out a new library to break an import cycle from canonpath use
Augie Fackler <raf@durin42.com>
parents: 19910
diff changeset
   839
                audit_path = pathutil.pathauditor(self._root)
18625
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
   840
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
   841
                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
   842
                    # 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
   843
                    # 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
   844
                    # 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
   845
                    # on disk.
24632
b2fb1403994e merge with stable
Matt Mackall <mpm@selenic.com>
parents: 24610 24621
diff changeset
   846
                    if (normalizefile and
b2fb1403994e merge with stable
Matt Mackall <mpm@selenic.com>
parents: 24610 24621
diff changeset
   847
                        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
   848
                        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
   849
                    # 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
   850
                    # 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
   851
                    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
   852
                        try:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
   853
                            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
   854
                            # 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
   855
                        except OSError:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
   856
                            # file doesn't exist
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
   857
                            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
   858
                    else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
   859
                        # 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
   860
                        # 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
   861
                        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
   862
            else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
   863
                # 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
   864
                # so stat and check everything we missed.
18625
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
   865
                nf = iter(visit).next
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
   866
                for st in util.statfiles([join(i) for i in visit]):
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
   867
                    results[nf()] = st
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
   868
        return results
669
8aa2a282eda4 .hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents: 667
diff changeset
   869
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
   870
    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
   871
        '''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
   872
        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
   873
        scmutil.status and:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   874
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   875
          unsure:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   876
            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
   877
            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
   878
            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
   879
          status.modified:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   880
            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
   881
            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
   882
          status.clean:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   883
            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
   884
            dirstate was written
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   885
        '''
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
   886
        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
   887
        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
   888
        removed, deleted, clean = [], [], []
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
   889
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   890
        dmap = self._map
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   891
        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
   892
        madd = modified.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   893
        aadd = added.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   894
        uadd = unknown.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   895
        iadd = ignored.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   896
        radd = removed.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   897
        dadd = deleted.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   898
        cadd = clean.append
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
   899
        mexact = match.exact
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
   900
        dirignore = self._dirignore
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
   901
        checkexec = self._checkexec
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
   902
        copymap = self._copymap
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
   903
        lastnormaltime = self._lastnormaltime
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   904
19191
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
   905
        # 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
   906
        # - we're listing all clean files, or
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
   907
        # - 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
   908
        #   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
   909
        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
   910
        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
   911
                                full=full).iteritems():
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
   912
            if fn not in dmap:
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
   913
                if (listignored or mexact(fn)) and dirignore(fn):
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
   914
                    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
   915
                        iadd(fn)
19910
601944f41257 dirstate.status: return explicit unknown files even when not asked
Siddharth Agarwal <sid0@fb.com>
parents: 19651
diff changeset
   916
                else:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   917
                    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
   918
                continue
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
   919
21810
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
   920
            # 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
   921
            # 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
   922
            # 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
   923
            # 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
   924
            # 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
   925
            # 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
   926
            # tuple members one by one.
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
   927
            t = dmap[fn]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
   928
            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
   929
            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
   930
            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
   931
            time = t[3]
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
   932
6818
6e93fbd847ef dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents: 6811
diff changeset
   933
            if not st and state in "nma":
6e93fbd847ef dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents: 6811
diff changeset
   934
                dadd(fn)
6e93fbd847ef dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents: 6811
diff changeset
   935
            elif state == 'n':
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   936
                mtime = int(st.st_mtime)
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
   937
                if (size >= 0 and
17733
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents: 17197
diff changeset
   938
                    ((size != st.st_size and size != st.st_size & _rangemask)
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
   939
                     or ((mode ^ st.st_mode) & 0100 and checkexec))
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   940
                    or size == -2 # other parent
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
   941
                    or fn in copymap):
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   942
                    madd(fn)
19651
902c646019ad dirstate.status: don't ignore symlink placeholders in the normal set
Siddharth Agarwal <sid0@fb.com>
parents: 19216
diff changeset
   943
                elif time != mtime and time != mtime & _rangemask:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   944
                    ladd(fn)
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
   945
                elif mtime == lastnormaltime:
24181
5245caa0dcde dirstate: clarify comment about leaving normal files undef if changed 'now'
Mads Kiilerich <madski@unity3d.com>
parents: 23866
diff changeset
   946
                    # 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
   947
                    # 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
   948
                    # This can happen if we quickly do multiple commits.
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   949
                    # 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
   950
                    ladd(fn)
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
   951
                elif listclean:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   952
                    cadd(fn)
6590
9f80e062d71c status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents: 6589
diff changeset
   953
            elif state == 'm':
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   954
                madd(fn)
6590
9f80e062d71c status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents: 6589
diff changeset
   955
            elif state == 'a':
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   956
                aadd(fn)
6590
9f80e062d71c status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents: 6589
diff changeset
   957
            elif state == 'r':
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   958
                radd(fn)
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
   959
22913
cb4449921a1d status: create class for status lists
Martin von Zweigbergk <martinvonz@gmail.com>
parents: 22911
diff changeset
   960
        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
   961
                                       unknown, ignored, clean))
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
   962
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
   963
    def matches(self, match):
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
   964
        '''
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
   965
        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
   966
        '''
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
   967
        dmap = self._map
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
   968
        if match.always():
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
   969
            return dmap.keys()
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
   970
        files = match.files()
24448
55c449345b10 match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents: 24212
diff changeset
   971
        if match.isexact():
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
   972
            # 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
   973
            # much smaller than dmap
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
   974
            return [f for f in files if f in dmap]
25151
6eb4bdad198f cleanup: use __builtins__.all instead of util.all
Augie Fackler <augie@google.com>
parents: 24833
diff changeset
   975
        if not match.anypats() 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
   976
            # 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
   977
            # that
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
   978
            return list(files)
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
   979
        return [f for f in dmap if match(f)]