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