mercurial/dirstate.py
author Bryan O'Sullivan <bryano@fb.com>
Tue, 23 Oct 2012 21:25:22 -0700
branchstable
changeset 17879 7b0b1da49f15
parent 17821 361ab1e2086f
child 17984 b74361cf7c0a
permissions -rw-r--r--
dirstate: handle dangling junctions on windows (issue2579)
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.
15799
e43c140eb08f dirstate: propagate IOError other than ENOENT when reading branch
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15670
diff changeset
     7
import errno
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
     8
6211
f89fd07fc51d Expand import * to allow Pyflakes to find problems
Joel Rosdahl <joel@rosdahl.net>
parents: 6201
diff changeset
     9
from node import nullid
3891
6b4127c7d52a Simplify i18n imports
Matt Mackall <mpm@selenic.com>
parents: 3877
diff changeset
    10
from i18n import _
13974
23f2736abce3 move checkfilename from util to scmutil
Adrian Buehlmann <adrian@cadifra.com>
parents: 13944
diff changeset
    11
import scmutil, util, ignore, osutil, parsers, encoding
8312
b87a50b7125c separate import lines from mercurial and general python modules
Simon Heimberg <simohe@besonet.ch>
parents: 8310
diff changeset
    12
import struct, os, stat, errno
9678
e2b1de5fee04 remove unused imports
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 9610
diff changeset
    13
import cStringIO
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
    14
4610
274c99fc629f dirstate: simplify state()
Matt Mackall <mpm@selenic.com>
parents: 4609
diff changeset
    15
_format = ">cllll"
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    16
propertycache = util.propertycache
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    17
filecache = scmutil.filecache
17733
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents: 17197
diff changeset
    18
_rangemask = 0x7fffffff
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    19
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    20
class repocache(filecache):
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    21
    """filecache for files in .hg/"""
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    22
    def join(self, obj, fname):
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    23
        return obj._opener.join(fname)
4610
274c99fc629f dirstate: simplify state()
Matt Mackall <mpm@selenic.com>
parents: 4609
diff changeset
    24
16202
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    25
class rootcache(filecache):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    26
    """filecache for files in the repository root"""
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    27
    def join(self, obj, fname):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    28
        return obj._join(fname)
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    29
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
    30
def _finddirs(path):
7032
7dfac37cfabf dirstate: improve performance for building _dirs
Matt Mackall <mpm@selenic.com>
parents: 7023
diff changeset
    31
    pos = path.rfind('/')
7dfac37cfabf dirstate: improve performance for building _dirs
Matt Mackall <mpm@selenic.com>
parents: 7023
diff changeset
    32
    while pos != -1:
7dfac37cfabf dirstate: improve performance for building _dirs
Matt Mackall <mpm@selenic.com>
parents: 7023
diff changeset
    33
        yield path[:pos]
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
    34
        pos = path.rfind('/', 0, pos)
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
    35
7096
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
    36
def _incdirs(dirs, path):
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
    37
    for base in _finddirs(path):
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
    38
        if base in dirs:
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
    39
            dirs[base] += 1
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
    40
            return
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
    41
        dirs[base] = 1
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
    42
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
    43
def _decdirs(dirs, path):
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
    44
    for base in _finddirs(path):
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
    45
        if dirs[base] > 1:
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
    46
            dirs[base] -= 1
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
    47
            return
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
    48
        del dirs[base]
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
    49
1559
59b3639df0a9 Convert all classes to new-style classes by deriving them from object.
Eric Hopper <hopper@omnifarious.org>
parents: 1541
diff changeset
    50
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
    51
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 12907
diff changeset
    52
    def __init__(self, opener, ui, root, validate):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    53
        '''Create a new dirstate object.
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    54
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    55
        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
    56
        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
    57
        the dirstate.
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    58
        '''
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
    59
        self._opener = opener
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 12907
diff changeset
    60
        self._validate = validate
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
    61
        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
    62
        self._rootdir = os.path.join(root, '')
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
    63
        self._dirty = False
4965
4106dde15aed Merge with crew
Matt Mackall <mpm@selenic.com>
parents: 4911 4953
diff changeset
    64
        self._dirtypl = False
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
    65
        self._lastnormaltime = 0
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
    66
        self._ui = ui
16200
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16143
diff changeset
    67
        self._filecache = {}
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
    68
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    69
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    70
    def _map(self):
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
    71
        '''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
    72
        (state, mode, size, time).'''
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    73
        self._read()
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    74
        return self._map
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    75
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    76
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    77
    def _copymap(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    78
        self._read()
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    79
        return self._copymap
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    80
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    81
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    82
    def _foldmap(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    83
        f = {}
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    84
        for name in self._map:
15550
b2fd4746414a dirstate: use util.normcase to build foldmap
Matt Mackall <mpm@selenic.com>
parents: 15488
diff changeset
    85
            f[util.normcase(name)] = name
16302
49b54f1ae053 dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents: 16258
diff changeset
    86
        for name in self._dirs:
49b54f1ae053 dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents: 16258
diff changeset
    87
            f[util.normcase(name)] = name
15668
8e020155e76c dirstate: prevent useless util.fspath() invocation for '.'
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15550
diff changeset
    88
        f['.'] = '.' # prevents useless util.fspath() invocation
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    89
        return f
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    90
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    91
    @repocache('branch')
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    92
    def _branch(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    93
        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
    94
            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
    95
        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
    96
            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
    97
                raise
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    98
            return "default"
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    99
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   100
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   101
    def _pl(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   102
        try:
13400
14f3795a5ed7 explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 13343
diff changeset
   103
            fp = self._opener("dirstate")
14f3795a5ed7 explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 13343
diff changeset
   104
            st = fp.read(40)
14f3795a5ed7 explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 13343
diff changeset
   105
            fp.close()
8716
f3322bb29a0e dirstate: don't complain about 0-length files
Matt Mackall <mpm@selenic.com>
parents: 8708
diff changeset
   106
            l = len(st)
f3322bb29a0e dirstate: don't complain about 0-length files
Matt Mackall <mpm@selenic.com>
parents: 8708
diff changeset
   107
            if l == 40:
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   108
                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
   109
            elif l > 0 and l < 40:
8640
8536119f2f94 dirstate: notice truncated parents read
Matt Mackall <mpm@selenic.com>
parents: 8589
diff changeset
   110
                raise util.Abort(_('working directory state appears damaged!'))
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   111
        except IOError, err:
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   112
            if err.errno != errno.ENOENT:
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   113
                raise
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   114
        return [nullid, nullid]
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   115
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   116
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   117
    def _dirs(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   118
        dirs = {}
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   119
        for f, s in self._map.iteritems():
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   120
            if s[0] != 'r':
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   121
                _incdirs(dirs, f)
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   122
        return dirs
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   123
16143
fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15801
diff changeset
   124
    def dirs(self):
fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15801
diff changeset
   125
        return self._dirs
fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15801
diff changeset
   126
16202
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
   127
    @rootcache('.hgignore')
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   128
    def _ignore(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   129
        files = [self._join('.hgignore')]
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   130
        for name, path in self._ui.configitems("ui"):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   131
            if name == 'ignore' or name.startswith('ignore.'):
9610
d78fe60f6bda make path expanding more consistent
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9518
diff changeset
   132
                files.append(util.expandpath(path))
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   133
        return ignore.ignore(self._root, files, self._ui.warn)
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   134
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   135
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   136
    def _slash(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   137
        return self._ui.configbool('ui', 'slash') and os.sep != '/'
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   138
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   139
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   140
    def _checklink(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   141
        return util.checklink(self._root)
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   142
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   143
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   144
    def _checkexec(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   145
        return util.checkexec(self._root)
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   146
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   147
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   148
    def _checkcase(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   149
        return not util.checkcase(self._join('.hg'))
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   150
4905
fc61495ea9cf dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents: 4904
diff changeset
   151
    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
   152
        # 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
   153
        # 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
   154
        return self._rootdir + f
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
   155
15337
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   156
    def flagfunc(self, buildfallback):
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   157
        if self._checklink and self._checkexec:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   158
            def f(x):
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   159
                p = self._join(x)
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   160
                if os.path.islink(p):
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   161
                    return 'l'
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   162
                if util.isexec(p):
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   163
                    return 'x'
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   164
                return ''
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   165
            return f
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   166
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   167
        fallback = buildfallback()
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   168
        if self._checklink:
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   169
            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
   170
                if os.path.islink(self._join(x)):
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   171
                    return 'l'
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   172
                if 'x' in fallback(x):
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   173
                    return 'x'
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   174
                return ''
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   175
            return f
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   176
        if self._checkexec:
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   177
            def f(x):
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   178
                if 'l' in fallback(x):
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   179
                    return 'l'
14273
38af0f514134 rename util.is_exec to isexec
Adrian Buehlmann <adrian@cadifra.com>
parents: 14168
diff changeset
   180
                if util.isexec(self._join(x)):
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   181
                    return 'x'
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   182
                return ''
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   183
            return f
15337
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   184
        else:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   185
            return fallback
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   186
870
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
   187
    def getcwd(self):
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
   188
        cwd = os.getcwd()
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   189
        if cwd == self._root:
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   190
            return ''
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   191
        # 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
   192
        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
   193
        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
   194
            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
   195
        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
   196
            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
   197
        else:
c93562fb12cc Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4229
diff changeset
   198
            # 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
   199
            return cwd
870
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
   200
4525
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4507
diff changeset
   201
    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
   202
        if cwd is None:
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4507
diff changeset
   203
            cwd = self.getcwd()
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   204
        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
   205
        if self._slash:
5842
111ed8c871bf Use util.normpath() instead of direct path string operation.
Shun-ichi GOTO <shunichi.goto@gmail.com>
parents: 5516
diff changeset
   206
            return util.normpath(path)
4527
b422b558015b Add ui.slash hgrc setting
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4525
diff changeset
   207
        return path
4525
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4507
diff changeset
   208
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   209
    def __getitem__(self, key):
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   210
        '''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
   211
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   212
        States are:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   213
          n  normal
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   214
          m  needs merging
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   215
          r  marked for removal
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   216
          a  marked for addition
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   217
          ?  not tracked
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   218
        '''
4906
30847b8af7ca dirstate: add __contains__ and make __getitem__ more useful
Matt Mackall <mpm@selenic.com>
parents: 4905
diff changeset
   219
        return self._map.get(key, ("?",))[0]
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
   220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
   221
    def __contains__(self, key):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   222
        return key in self._map
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   223
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   224
    def __iter__(self):
8209
a1a5a57efe90 replace util.sort with sorted built-in
Matt Mackall <mpm@selenic.com>
parents: 8151
diff changeset
   225
        for x in sorted(self._map):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   226
            yield x
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
   227
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
   228
    def parents(self):
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 12907
diff changeset
   229
        return [self._validate(p) for p in self._pl]
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
   230
13876
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   231
    def p1(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   232
        return self._validate(self._pl[0])
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   233
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   234
    def p2(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   235
        return self._validate(self._pl[1])
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   236
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
   237
    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
   238
        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
   239
1062
6d5a62a549fa pep-0008 cleanup
benoit.boissinot@ens-lyon.fr
parents: 1040
diff changeset
   240
    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
   241
        """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
   242
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   243
        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
   244
        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
   245
        returned by the call.
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   246
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   247
        See localrepo.setparents()
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   248
        """
4965
4106dde15aed Merge with crew
Matt Mackall <mpm@selenic.com>
parents: 4911 4953
diff changeset
   249
        self._dirty = self._dirtypl = True
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   250
        oldp2 = self._pl[1]
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   251
        self._pl = p1, p2
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   252
        copies = {}
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   253
        if oldp2 != nullid and p2 == nullid:
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   254
            # Discard 'm' markers when moving away from a merge state
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   255
            for f, s in self._map.iteritems():
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   256
                if s[0] == 'm':
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   257
                    if f in self._copymap:
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   258
                        copies[f] = self._copymap[f]
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   259
                    self.normallookup(f)
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   260
        return copies
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
   261
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
   262
    def setbranch(self, branch):
17819
ec892050f3c7 dirstate: use scmutil.checknewlabel to check new branch name
Kevin Bullock <kbullock@ringworld.org>
parents: 17733
diff changeset
   263
        # no repo object here, just check for reserved names
17821
361ab1e2086f scmutil: add bad character checking to checknewlabel
Kevin Bullock <kbullock@ringworld.org>
parents: 17819
diff changeset
   264
        scmutil.checknewlabel(None, branch, 'branch')
13047
6c375e07d673 branch: operate on branch names in local string space where possible
Matt Mackall <mpm@selenic.com>
parents: 13032
diff changeset
   265
        self._branch = encoding.fromlocal(branch)
16472
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   266
        f = self._opener('branch', 'w', atomictemp=True)
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   267
        try:
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   268
            f.write(self._branch + '\n')
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   269
        finally:
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   270
            f.close()
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
   271
4615
9b00b73a5286 dirstate: hide some more internals
Matt Mackall <mpm@selenic.com>
parents: 4614
diff changeset
   272
    def _read(self):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   273
        self._map = {}
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   274
        self._copymap = {}
4607
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   275
        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
   276
            st = self._opener.read("dirstate")
4607
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   277
        except IOError, err:
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   278
            if err.errno != errno.ENOENT:
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   279
                raise
4607
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   280
            return
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   281
        if not st:
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   282
            return
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   283
7128
2b8a2248312a get rid of semi-colon introduced in 16bafcebd3d1
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 7119
diff changeset
   284
        p = parsers.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
   285
        if not self._dirtypl:
7093
16bafcebd3d1 dirstate: C parsing extension
Matt Mackall <mpm@selenic.com>
parents: 7069
diff changeset
   286
            self._pl = p
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
   287
4613
3a645af7fb76 localrepo and dirstate: rename reload to invalidate
Matt Mackall <mpm@selenic.com>
parents: 4612
diff changeset
   288
    def invalidate(self):
13200
6f011cf52f9a avoid .split() in for loops and use tuples instead
David Soria Parra <dsp@php.net>
parents: 13047
diff changeset
   289
        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
   290
                "_ignore"):
4953
6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4952
diff changeset
   291
            if a in self.__dict__:
6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4952
diff changeset
   292
                delattr(self, a)
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
   293
        self._lastnormaltime = 0
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
   294
        self._dirty = False
4375
109077e7048d When reloading the dirstate, recompute ignore information if needed.
Bryan O'Sullivan <bos@serpentine.com>
parents: 4374
diff changeset
   295
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
   296
    def copy(self, source, dest):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   297
        """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
   298
        if source == dest:
deda205a00e1 Ignore dummy copies in dirstate and localrepo.filecommit()
Patrick Mezard <pmezard@gmail.com>
parents: 6479
diff changeset
   299
            return
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
   300
        self._dirty = True
7566
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents: 7280
diff changeset
   301
        if source is not None:
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents: 7280
diff changeset
   302
            self._copymap[dest] = source
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents: 7280
diff changeset
   303
        elif dest in self._copymap:
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents: 7280
diff changeset
   304
            del self._copymap[dest]
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
   305
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
   306
    def copied(self, file):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   307
        return self._copymap.get(file, None)
3154
b1f10d3223c1 dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents: 2962
diff changeset
   308
b1f10d3223c1 dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents: 2962
diff changeset
   309
    def copies(self):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   310
        return self._copymap
515
03f27b1381f9 Whitespace cleanups
mpm@selenic.com
parents: 514
diff changeset
   311
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   312
    def _droppath(self, f):
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   313
        if self[f] not in "?r" and "_dirs" in self.__dict__:
7096
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
   314
            _decdirs(self._dirs, f)
2953
3d5547845158 fix issue 322.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2859
diff changeset
   315
17196
2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents: 17094
diff changeset
   316
    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
   317
        oldstate = self[f]
17196
2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents: 17094
diff changeset
   318
        if state == 'a' or oldstate == 'r':
13974
23f2736abce3 move checkfilename from util to scmutil
Adrian Buehlmann <adrian@cadifra.com>
parents: 13944
diff changeset
   319
            scmutil.checkfilename(f)
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   320
            if f in self._dirs:
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   321
                raise util.Abort(_('directory %r already in dirstate') % f)
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   322
            # shadows
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   323
            for d in _finddirs(f):
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   324
                if d in self._dirs:
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   325
                    break
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   326
                if d in self._map and self[d] != 'r':
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   327
                    raise util.Abort(
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   328
                        _('file %r in dirstate clashes with %r') % (d, f))
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   329
        if oldstate in "?r" and "_dirs" in self.__dict__:
7096
6dab29f6df37 dirstate._dirs: fix refcounting broken by 7dfac37cfabf
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7093
diff changeset
   330
            _incdirs(self._dirs, f)
17094
c2016bae3b97 dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents: 16955
diff changeset
   331
        self._dirty = True
c2016bae3b97 dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents: 16955
diff changeset
   332
        self._map[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
   333
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   334
    def normal(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   335
        '''Mark a file normal and clean.'''
4905
fc61495ea9cf dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents: 4904
diff changeset
   336
        s = os.lstat(self._join(f))
13754
ae157ca56cd5 dirstate: check mtime when adding to _lastnormal
Adrian Buehlmann <adrian@cadifra.com>
parents: 13743
diff changeset
   337
        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
   338
        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
   339
                      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
   340
        if f in self._copymap:
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   341
            del self._copymap[f]
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   342
        if mtime > self._lastnormaltime:
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   343
            # 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
   344
            # 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
   345
            # modifications that happen within the same timeslot.
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   346
            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
   347
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
   348
    def normallookup(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   349
        '''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
   350
        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
   351
            # 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
   352
            # 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
   353
            # 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
   354
            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
   355
            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
   356
                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
   357
                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
   358
                    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
   359
                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
   360
                    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
   361
                if source:
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   362
                    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
   363
                return
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   364
            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
   365
                return
17094
c2016bae3b97 dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents: 16955
diff changeset
   366
        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
   367
        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
   368
            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
   369
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   370
    def otherparent(self, f):
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   371
        '''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
   372
        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
   373
            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
   374
                               "only allowed in merges") % f)
17094
c2016bae3b97 dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents: 16955
diff changeset
   375
        self._addpath(f, 'n', 0, -2, -1)
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   376
        if f in self._copymap:
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   377
            del self._copymap[f]
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   378
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   379
    def add(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   380
        '''Mark a file added.'''
17196
2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents: 17094
diff changeset
   381
        self._addpath(f, 'a', 0, -1, -1)
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   382
        if f in self._copymap:
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   383
            del self._copymap[f]
4616
70352337934e dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents: 4615
diff changeset
   384
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   385
    def remove(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   386
        '''Mark a file removed.'''
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   387
        self._dirty = True
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   388
        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
   389
        size = 0
fed1a9c22076 dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6257
diff changeset
   390
        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
   391
            # 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
   392
            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
   393
            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
   394
                size = -1
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   395
            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
   396
                size = -2
7093
16bafcebd3d1 dirstate: C parsing extension
Matt Mackall <mpm@selenic.com>
parents: 7069
diff changeset
   397
        self._map[f] = ('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
   398
        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
   399
            del self._copymap[f]
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   400
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   401
    def merge(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   402
        '''Mark a file merged.'''
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   403
        if self._pl[1] == nullid:
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   404
            return self.normallookup(f)
4905
fc61495ea9cf dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents: 4904
diff changeset
   405
        s = os.lstat(self._join(f))
17733
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents: 17197
diff changeset
   406
        self._addpath(f, 'm', s.st_mode,
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents: 17197
diff changeset
   407
                      s.st_size & _rangemask, int(s.st_mtime) & _rangemask)
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   408
        if f in self._copymap:
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   409
            del self._copymap[f]
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   410
14434
cc8c09855d19 dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents: 14273
diff changeset
   411
    def drop(self, f):
cc8c09855d19 dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents: 14273
diff changeset
   412
        '''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
   413
        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
   414
            self._dirty = True
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents: 15337
diff changeset
   415
            self._droppath(f)
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents: 15337
diff changeset
   416
            del self._map[f]
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   417
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   418
    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
   419
        normed = util.normcase(path)
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   420
        folded = self._foldmap.get(normed, None)
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   421
        if folded is None:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   422
            if isknown:
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   423
                folded = path
7068
57377fa7eda2 issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents: 7034
diff changeset
   424
            else:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   425
                if exists is None:
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   426
                    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
   427
                if not exists:
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   428
                    # Maybe a path component exists
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   429
                    if not ignoremissing and '/' in path:
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   430
                        d, f = path.rsplit('/', 1)
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   431
                        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
   432
                        folded = d + "/" + f
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   433
                    else:
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   434
                        # No path components, preserve original case
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   435
                        folded = path
16302
49b54f1ae053 dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents: 16258
diff changeset
   436
                else:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   437
                    # recursively normalize leading directory components
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   438
                    # against dirstate
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   439
                    if '/' in normed:
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   440
                        d, f = normed.rsplit('/', 1)
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   441
                        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
   442
                        r = self._root + "/" + d
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   443
                        folded = d + "/" + util.fspath(f, r)
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   444
                    else:
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   445
                        folded = util.fspath(normed, self._root)
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   446
                    self._foldmap[normed] = folded
16302
49b54f1ae053 dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents: 16258
diff changeset
   447
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   448
        return folded
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   449
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   450
    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
   451
        '''
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   452
        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
   453
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   454
        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
   455
        disk, to avoid extra filesystem access.
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   456
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   457
        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
   458
        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
   459
        existing path components.
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   460
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   461
        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
   462
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   463
        - 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
   464
        - version of name stored on disk
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   465
        - version provided via command arguments
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   466
        '''
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   467
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   468
        if self._checkcase:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   469
            return self._normalize(path, isknown, ignoremissing)
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   470
        return path
6677
9865e15febd0 Add a normalize() method to dirstate
Paul Moore <p.f.moore@gmail.com>
parents: 6675
diff changeset
   471
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   472
    def clear(self):
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   473
        self._map = {}
5487
7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660).
Maxim Dounin <mdounin@mdounin.ru>
parents: 5396
diff changeset
   474
        if "_dirs" in self.__dict__:
10394
4612cded5176 fix coding style (reported by pylint)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10282
diff changeset
   475
            delattr(self, "_dirs")
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   476
        self._copymap = {}
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   477
        self._pl = [nullid, nullid]
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
   478
        self._lastnormaltime = 0
5123
79373ec3f27d merge with crew-stable
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5045 5065
diff changeset
   479
        self._dirty = True
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   480
1755
a8f7791e3680 add 'debugrebuildstate' to rebuild the dirstate from a given revision
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1749
diff changeset
   481
    def rebuild(self, parent, files):
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   482
        self.clear()
2832
e196aa1df169 Start using manifestflags methods
Matt Mackall <mpm@selenic.com>
parents: 2486
diff changeset
   483
        for f in files:
6750
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6749
diff changeset
   484
            if 'x' in files.flags(f):
7093
16bafcebd3d1 dirstate: C parsing extension
Matt Mackall <mpm@selenic.com>
parents: 7069
diff changeset
   485
                self._map[f] = ('n', 0777, -1, 0)
1755
a8f7791e3680 add 'debugrebuildstate' to rebuild the dirstate from a given revision
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1749
diff changeset
   486
            else:
7093
16bafcebd3d1 dirstate: C parsing extension
Matt Mackall <mpm@selenic.com>
parents: 7069
diff changeset
   487
                self._map[f] = ('n', 0666, -1, 0)
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   488
        self._pl = (parent, nullid)
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
   489
        self._dirty = True
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   490
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   491
    def write(self):
4612
17ee7407097f dirstate: simplify dirty handling
Matt Mackall <mpm@selenic.com>
parents: 4611
diff changeset
   492
        if not self._dirty:
1794
98b6c1cad58b only write the dirstate when something changed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1755
diff changeset
   493
            return
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
   494
        st = self._opener("dirstate", "w", atomictemp=True)
6327
6d952dc2abc9 dirstate: refactor granularity code, add a test
Matt Mackall <mpm@selenic.com>
parents: 6326
diff changeset
   495
16955
92e1c64ba0d4 parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents: 16686
diff changeset
   496
        def finish(s):
92e1c64ba0d4 parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents: 16686
diff changeset
   497
            st.write(s)
92e1c64ba0d4 parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents: 16686
diff changeset
   498
            st.close()
92e1c64ba0d4 parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents: 16686
diff changeset
   499
            self._lastnormaltime = 0
92e1c64ba0d4 parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents: 16686
diff changeset
   500
            self._dirty = self._dirtypl = False
92e1c64ba0d4 parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents: 16686
diff changeset
   501
9509
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   502
        # 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
   503
        # 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
   504
        now = util.fstat(st).st_mtime
92e1c64ba0d4 parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents: 16686
diff changeset
   505
        copymap = self._copymap
92e1c64ba0d4 parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents: 16686
diff changeset
   506
        try:
92e1c64ba0d4 parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents: 16686
diff changeset
   507
            finish(parsers.pack_dirstate(self._map, copymap, self._pl, now))
92e1c64ba0d4 parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents: 16686
diff changeset
   508
            return
92e1c64ba0d4 parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents: 16686
diff changeset
   509
        except AttributeError:
92e1c64ba0d4 parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents: 16686
diff changeset
   510
            pass
10865
3492f443f579 dirstate: no need to iterate twice, a dict can be updated in place
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10836
diff changeset
   511
16955
92e1c64ba0d4 parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents: 16686
diff changeset
   512
        now = int(now)
10865
3492f443f579 dirstate: no need to iterate twice, a dict can be updated in place
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10836
diff changeset
   513
        cs = cStringIO.StringIO()
3492f443f579 dirstate: no need to iterate twice, a dict can be updated in place
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10836
diff changeset
   514
        pack = struct.pack
3492f443f579 dirstate: no need to iterate twice, a dict can be updated in place
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10836
diff changeset
   515
        write = cs.write
3492f443f579 dirstate: no need to iterate twice, a dict can be updated in place
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10836
diff changeset
   516
        write("".join(self._pl))
3492f443f579 dirstate: no need to iterate twice, a dict can be updated in place
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10836
diff changeset
   517
        for f, e in self._map.iteritems():
9509
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   518
            if e[0] == 'n' and e[3] == now:
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   519
                # The file was last modified "simultaneously" with the current
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   520
                # write to dirstate (i.e. within the same second for file-
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   521
                # systems with a granularity of 1 sec). This commonly happens
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   522
                # for at least a couple of files on 'update'.
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   523
                # The user could change the file without changing its size
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   524
                # within the same second. Invalidate the file's stat data in
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   525
                # dirstate, forcing future 'status' calls to compare the
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   526
                # contents of the file. This prevents mistakenly treating such
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   527
                # files as clean.
10865
3492f443f579 dirstate: no need to iterate twice, a dict can be updated in place
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10836
diff changeset
   528
                e = (e[0], 0, -1, -1)   # mark entry as 'unset'
3492f443f579 dirstate: no need to iterate twice, a dict can be updated in place
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10836
diff changeset
   529
                self._map[f] = e
9509
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   530
10836
e5aaa4543289 dirstate: fix in memory dirstate entries for 1-second race
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10420
diff changeset
   531
            if f in copymap:
e5aaa4543289 dirstate: fix in memory dirstate entries for 1-second race
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10420
diff changeset
   532
                f = "%s\0%s" % (f, copymap[f])
5327
f46ab9cacd3c dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents: 5326
diff changeset
   533
            e = pack(_format, e[0], e[1], e[2], e[3], len(f))
f46ab9cacd3c dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents: 5326
diff changeset
   534
            write(e)
f46ab9cacd3c dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents: 5326
diff changeset
   535
            write(f)
16955
92e1c64ba0d4 parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents: 16686
diff changeset
   536
        finish(cs.getvalue())
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   537
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   538
    def _dirignore(self, f):
6479
31abcae33b4f dirstate: do not ignore current directory '.' (issue 1078)
Patrick Mezard <pmezard@gmail.com>
parents: 6327
diff changeset
   539
        if f == '.':
31abcae33b4f dirstate: do not ignore current directory '.' (issue 1078)
Patrick Mezard <pmezard@gmail.com>
parents: 6327
diff changeset
   540
            return False
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   541
        if self._ignore(f):
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   542
            return True
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   543
        for p in _finddirs(f):
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   544
            if self._ignore(p):
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   545
                return True
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   546
        return False
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   547
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
   548
    def walk(self, match, subrepos, unknown, ignored):
3529
09d99b7e4da0 simplify dirstate walking
Matt Mackall <mpm@selenic.com>
parents: 3223
diff changeset
   549
        '''
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   550
        Walk recursively through the directory tree, finding all files
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   551
        matched by match.
3529
09d99b7e4da0 simplify dirstate walking
Matt Mackall <mpm@selenic.com>
parents: 3223
diff changeset
   552
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   553
        Return a dict mapping filename to stat-like object (either
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   554
        mercurial.osutil.stat instance or return value of os.stat()).
3529
09d99b7e4da0 simplify dirstate walking
Matt Mackall <mpm@selenic.com>
parents: 3223
diff changeset
   555
        '''
879
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
   556
6578
f242d3684f83 walk: begin refactoring badmatch handling
Matt Mackall <mpm@selenic.com>
parents: 6577
diff changeset
   557
        def fwarn(f, msg):
7023
74be9d0c665c dirstate: use the right variable (f, not ff)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7008
diff changeset
   558
            self._ui.warn('%s: %s\n' % (self.pathto(f), msg))
6578
f242d3684f83 walk: begin refactoring badmatch handling
Matt Mackall <mpm@selenic.com>
parents: 6577
diff changeset
   559
            return False
f242d3684f83 walk: begin refactoring badmatch handling
Matt Mackall <mpm@selenic.com>
parents: 6577
diff changeset
   560
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
   561
        def badtype(mode):
8310
8417d82d3969 dirstate: translate forgotten string
Simon Heimberg <simohe@besonet.ch>
parents: 8261
diff changeset
   562
            kind = _('unknown')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   563
            if stat.S_ISCHR(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   564
                kind = _('character device')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   565
            elif stat.S_ISBLK(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   566
                kind = _('block device')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   567
            elif stat.S_ISFIFO(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   568
                kind = _('fifo')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   569
            elif stat.S_ISSOCK(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   570
                kind = _('socket')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   571
            elif stat.S_ISDIR(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   572
                kind = _('directory')
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
   573
            return _('unsupported file type (type is %s)') % kind
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   574
4609
b43f17691ae6 dirstate: move ignore to its own file
Matt Mackall <mpm@selenic.com>
parents: 4608
diff changeset
   575
        ignore = self._ignore
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   576
        dirignore = self._dirignore
4193
dd0d9bd91e0a dirstate.statwalk: explicitly test for ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4172
diff changeset
   577
        if ignored:
dd0d9bd91e0a dirstate.statwalk: explicitly test for ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4172
diff changeset
   578
            ignore = util.never
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   579
            dirignore = util.never
6971
b3bc518a73c3 performance: do not stat() things when not required
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 6834
diff changeset
   580
        elif not unknown:
b3bc518a73c3 performance: do not stat() things when not required
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 6834
diff changeset
   581
            # if unknown and ignored are False, skip step 2
b3bc518a73c3 performance: do not stat() things when not required
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 6834
diff changeset
   582
            ignore = util.always
b3bc518a73c3 performance: do not stat() things when not required
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 6834
diff changeset
   583
            dirignore = util.always
3534
549cb7b640fb Simplify ignore logic in dirstate.walk
Matt Mackall <mpm@selenic.com>
parents: 3532
diff changeset
   584
6834
cbdfd08eabc9 dirstate.walk: speed up calling match function
Matt Mackall <mpm@selenic.com>
parents: 6833
diff changeset
   585
        matchfn = match.matchfn
8676
acd69fc201a5 walk: we always have a badfn
Matt Mackall <mpm@selenic.com>
parents: 8675
diff changeset
   586
        badfn = match.bad
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   587
        dmap = self._map
5000
46facb73ba8b dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents: 4965
diff changeset
   588
        normpath = util.normpath
5396
5105b119edd2 Add osutil module, containing a listdir function.
Bryan O'Sullivan <bos@serpentine.com>
parents: 5327
diff changeset
   589
        listdir = osutil.listdir
5000
46facb73ba8b dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents: 4965
diff changeset
   590
        lstat = os.lstat
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   591
        getkind = stat.S_IFMT
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
   592
        dirkind = stat.S_IFDIR
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   593
        regkind = stat.S_IFREG
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   594
        lnkkind = stat.S_IFLNK
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   595
        join = self._join
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   596
        work = []
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   597
        wadd = work.append
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   598
8684
5bb7780b57c7 match: fold plan cases down to two special cases
Matt Mackall <mpm@selenic.com>
parents: 8683
diff changeset
   599
        exact = skipstep3 = False
5bb7780b57c7 match: fold plan cases down to two special cases
Matt Mackall <mpm@selenic.com>
parents: 8683
diff changeset
   600
        if matchfn == match.exact: # match.exact
8683
99eb4dcb37ce walk: refactor walk plan
Matt Mackall <mpm@selenic.com>
parents: 8681
diff changeset
   601
            exact = True
8684
5bb7780b57c7 match: fold plan cases down to two special cases
Matt Mackall <mpm@selenic.com>
parents: 8683
diff changeset
   602
            dirignore = util.always # skip step 2
5bb7780b57c7 match: fold plan cases down to two special cases
Matt Mackall <mpm@selenic.com>
parents: 8683
diff changeset
   603
        elif match.files() and not match.anypats(): # match.match, no patterns
5bb7780b57c7 match: fold plan cases down to two special cases
Matt Mackall <mpm@selenic.com>
parents: 8683
diff changeset
   604
            skipstep3 = True
8589
3edf133dcb5a dirstate: skip step 3 in walk if nothing new will match
Simon Heimberg <simohe@besonet.ch>
parents: 8588
diff changeset
   605
16313
e785456f9631 dirstate: avoid normalizing letter case on icasefs for exact match (issue3340)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16302
diff changeset
   606
        if not exact and self._checkcase:
12907
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
   607
            normalize = self._normalize
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
   608
            skipstep3 = False
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
   609
        else:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   610
            normalize = lambda x, y, z: x
12907
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
   611
12211
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   612
        files = sorted(match.files())
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   613
        subrepos.sort()
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   614
        i, j = 0, 0
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   615
        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
   616
            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
   617
            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
   618
                i += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   619
                continue
13339
22167be007ed subrepo: fix pruning of subrepo filenames in dirstate (issue2619)
trbs <trbs@trbs.net>
parents: 13233
diff changeset
   620
            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
   621
                del files[i]
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   622
            j += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   623
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   624
        if not files or '.' in files:
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   625
            files = ['']
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
   626
        results = dict.fromkeys(subrepos)
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
   627
        results['.hg'] = None
5000
46facb73ba8b dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents: 4965
diff changeset
   628
6826
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents: 6825
diff changeset
   629
        # step 1: find all explicit files
12211
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   630
        for ff in files:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   631
            nf = normalize(normpath(ff), False, True)
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
   632
            if nf in results:
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   633
                continue
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   634
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   635
            try:
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   636
                st = lstat(join(nf))
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   637
                kind = getkind(st.st_mode)
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   638
                if kind == dirkind:
8684
5bb7780b57c7 match: fold plan cases down to two special cases
Matt Mackall <mpm@selenic.com>
parents: 8683
diff changeset
   639
                    skipstep3 = False
8588
2624f485b9bc dirstate: set more states in step 1 of walk
Simon Heimberg <simohe@besonet.ch>
parents: 8521
diff changeset
   640
                    if nf in dmap:
8645
27638a233577 dirstate: fixed typo in comment
Martin Geisler <mg@lazybytes.net>
parents: 8640
diff changeset
   641
                        #file deleted 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
   642
                        results[nf] = None
8708
a645904c88c4 dirstate: more accurate use of match.dir callback
Matt Mackall <mpm@selenic.com>
parents: 8684
diff changeset
   643
                    match.dir(nf)
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
   644
                    if not dirignore(nf):
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
   645
                        wadd(nf)
12401
4cdaf1adafc8 backout most of 4f8067c94729
Matt Mackall <mpm@selenic.com>
parents: 12387
diff changeset
   646
                elif kind == regkind or kind == lnkkind:
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   647
                    results[nf] = st
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
   648
                else:
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
   649
                    badfn(ff, badtype(kind))
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   650
                    if nf in dmap:
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
   651
                        results[nf] = None
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   652
            except OSError, inst:
8675
fb74e1e69da0 walk: simplify check for missing file
Matt Mackall <mpm@selenic.com>
parents: 8645
diff changeset
   653
                if nf in dmap: # does it exactly match a file?
fb74e1e69da0 walk: simplify check for missing file
Matt Mackall <mpm@selenic.com>
parents: 8645
diff changeset
   654
                    results[nf] = None
fb74e1e69da0 walk: simplify check for missing file
Matt Mackall <mpm@selenic.com>
parents: 8645
diff changeset
   655
                else: # does it match a directory?
fb74e1e69da0 walk: simplify check for missing file
Matt Mackall <mpm@selenic.com>
parents: 8645
diff changeset
   656
                    prefix = nf + "/"
fb74e1e69da0 walk: simplify check for missing file
Matt Mackall <mpm@selenic.com>
parents: 8645
diff changeset
   657
                    for fn in dmap:
fb74e1e69da0 walk: simplify check for missing file
Matt Mackall <mpm@selenic.com>
parents: 8645
diff changeset
   658
                        if fn.startswith(prefix):
8708
a645904c88c4 dirstate: more accurate use of match.dir callback
Matt Mackall <mpm@selenic.com>
parents: 8684
diff changeset
   659
                            match.dir(nf)
8684
5bb7780b57c7 match: fold plan cases down to two special cases
Matt Mackall <mpm@selenic.com>
parents: 8683
diff changeset
   660
                            skipstep3 = False
8675
fb74e1e69da0 walk: simplify check for missing file
Matt Mackall <mpm@selenic.com>
parents: 8645
diff changeset
   661
                            break
8677
34df078b8b1b walk: simplify logic for badfn clause
Matt Mackall <mpm@selenic.com>
parents: 8676
diff changeset
   662
                    else:
8680
b6511055d37b match: ignore return of match.bad
Matt Mackall <mpm@selenic.com>
parents: 8677
diff changeset
   663
                        badfn(ff, inst.strerror)
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   664
6826
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents: 6825
diff changeset
   665
        # step 2: visit subdirectories
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents: 6825
diff changeset
   666
        while work:
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents: 6825
diff changeset
   667
            nd = work.pop()
7099
6f750e76fb46 dirstate.walk: skip unreadable directories (issue1213)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7096
diff changeset
   668
            skip = None
6826
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents: 6825
diff changeset
   669
            if nd == '.':
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents: 6825
diff changeset
   670
                nd = ''
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents: 6825
diff changeset
   671
            else:
7099
6f750e76fb46 dirstate.walk: skip unreadable directories (issue1213)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7096
diff changeset
   672
                skip = '.hg'
6f750e76fb46 dirstate.walk: skip unreadable directories (issue1213)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7096
diff changeset
   673
            try:
6f750e76fb46 dirstate.walk: skip unreadable directories (issue1213)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7096
diff changeset
   674
                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
   675
            except OSError, inst:
17879
7b0b1da49f15 dirstate: handle dangling junctions on windows (issue2579)
Bryan O'Sullivan <bryano@fb.com>
parents: 17821
diff changeset
   676
                if inst.errno in (errno.EACCES, errno.ENOENT):
7099
6f750e76fb46 dirstate.walk: skip unreadable directories (issue1213)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7096
diff changeset
   677
                    fwarn(nd, inst.strerror)
6f750e76fb46 dirstate.walk: skip unreadable directories (issue1213)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7096
diff changeset
   678
                    continue
6f750e76fb46 dirstate.walk: skip unreadable directories (issue1213)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 7096
diff changeset
   679
                raise
6826
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents: 6825
diff changeset
   680
            for f, kind, st in entries:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   681
                nf = normalize(nd and (nd + "/" + f) or f, True, True)
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
   682
                if nf not in results:
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
   683
                    if kind == dirkind:
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
   684
                        if not ignore(nf):
8708
a645904c88c4 dirstate: more accurate use of match.dir callback
Matt Mackall <mpm@selenic.com>
parents: 8684
diff changeset
   685
                            match.dir(nf)
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
   686
                            wadd(nf)
6834
cbdfd08eabc9 dirstate.walk: speed up calling match function
Matt Mackall <mpm@selenic.com>
parents: 6833
diff changeset
   687
                        if nf in dmap and matchfn(nf):
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
   688
                            results[nf] = None
6832
643ff33812f8 dirstate.walk: inline imatch
Matt Mackall <mpm@selenic.com>
parents: 6831
diff changeset
   689
                    elif kind == regkind or kind == lnkkind:
643ff33812f8 dirstate.walk: inline imatch
Matt Mackall <mpm@selenic.com>
parents: 6831
diff changeset
   690
                        if nf in dmap:
6834
cbdfd08eabc9 dirstate.walk: speed up calling match function
Matt Mackall <mpm@selenic.com>
parents: 6833
diff changeset
   691
                            if matchfn(nf):
6832
643ff33812f8 dirstate.walk: inline imatch
Matt Mackall <mpm@selenic.com>
parents: 6831
diff changeset
   692
                                results[nf] = st
6834
cbdfd08eabc9 dirstate.walk: speed up calling match function
Matt Mackall <mpm@selenic.com>
parents: 6833
diff changeset
   693
                        elif 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
   694
                            results[nf] = st
6834
cbdfd08eabc9 dirstate.walk: speed up calling match function
Matt Mackall <mpm@selenic.com>
parents: 6833
diff changeset
   695
                    elif nf in dmap and matchfn(nf):
6832
643ff33812f8 dirstate.walk: inline imatch
Matt Mackall <mpm@selenic.com>
parents: 6831
diff changeset
   696
                        results[nf] = None
536
c15b4bc0a11c Refactor diffrevs/diffdir into changes
mpm@selenic.com
parents: 529
diff changeset
   697
6826
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents: 6825
diff changeset
   698
        # step 3: report unseen items in the dmap hash
8684
5bb7780b57c7 match: fold plan cases down to two special cases
Matt Mackall <mpm@selenic.com>
parents: 8683
diff changeset
   699
        if not skipstep3 and not exact:
8589
3edf133dcb5a dirstate: skip step 3 in walk if nothing new will match
Simon Heimberg <simohe@besonet.ch>
parents: 8588
diff changeset
   700
            visit = sorted([f for f in dmap if f not in results and matchfn(f)])
3edf133dcb5a dirstate: skip step 3 in walk if nothing new will match
Simon Heimberg <simohe@besonet.ch>
parents: 8588
diff changeset
   701
            for nf, st in zip(visit, util.statfiles([join(i) for i in visit])):
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16551
diff changeset
   702
                if (not st is None and
16686
67964cda8701 cleanup: "not x in y" -> "x not in y"
Brodie Rao <brodie@sf.io>
parents: 16683
diff changeset
   703
                    getkind(st.st_mode) not in (regkind, lnkkind)):
8589
3edf133dcb5a dirstate: skip step 3 in walk if nothing new will match
Simon Heimberg <simohe@besonet.ch>
parents: 8588
diff changeset
   704
                    st = None
3edf133dcb5a dirstate: skip step 3 in walk if nothing new will match
Simon Heimberg <simohe@besonet.ch>
parents: 8588
diff changeset
   705
                results[nf] = st
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
   706
        for s in subrepos:
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
   707
            del results[s]
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   708
        del results['.hg']
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
   709
        return results
669
8aa2a282eda4 .hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents: 667
diff changeset
   710
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
   711
    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
   712
        '''Determine the status of the working copy relative to the
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   713
        dirstate and return a tuple of lists (unsure, modified, added,
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   714
        removed, deleted, unknown, ignored, clean), where:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   715
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   716
          unsure:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   717
            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
   718
            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
   719
            but mtime differs)
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   720
          modified:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   721
            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
   722
            was written (different size or mode)
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   723
          added:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   724
            files that have been explicitly added with hg add
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   725
          removed:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   726
            files that have been explicitly removed with hg remove
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   727
          deleted:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   728
            files that have been deleted through other means ("missing")
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   729
          unknown:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   730
            files not in the dirstate that are not ignored
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   731
          ignored:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   732
            files not in the dirstate that are ignored
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   733
            (by _dirignore())
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   734
          clean:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   735
            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
   736
            dirstate was written
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   737
        '''
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
   738
        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
   739
        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
   740
        removed, deleted, clean = [], [], []
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
   741
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   742
        dmap = self._map
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   743
        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
   744
        madd = modified.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   745
        aadd = added.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   746
        uadd = unknown.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   747
        iadd = ignored.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   748
        radd = removed.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   749
        dadd = deleted.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   750
        cadd = clean.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   751
11769
ca6cebd8734e dirstate: ignore symlinks when fs cannot handle them (issue1888)
Martin Geisler <mg@aragost.com>
parents: 10968
diff changeset
   752
        lnkkind = stat.S_IFLNK
ca6cebd8734e dirstate: ignore symlinks when fs cannot handle them (issue1888)
Martin Geisler <mg@aragost.com>
parents: 10968
diff changeset
   753
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
   754
        for fn, st in self.walk(match, subrepos, listunknown,
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
   755
                                listignored).iteritems():
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
   756
            if fn not in dmap:
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
   757
                if (listignored or match.exact(fn)) and self._dirignore(fn):
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
   758
                    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
   759
                        iadd(fn)
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
   760
                elif listunknown:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   761
                    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
   762
                continue
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
   763
7093
16bafcebd3d1 dirstate: C parsing extension
Matt Mackall <mpm@selenic.com>
parents: 7069
diff changeset
   764
            state, mode, size, time = dmap[fn]
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
   765
6818
6e93fbd847ef dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents: 6811
diff changeset
   766
            if not st and state in "nma":
6e93fbd847ef dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents: 6811
diff changeset
   767
                dadd(fn)
6e93fbd847ef dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents: 6811
diff changeset
   768
            elif state == 'n':
11769
ca6cebd8734e dirstate: ignore symlinks when fs cannot handle them (issue1888)
Martin Geisler <mg@aragost.com>
parents: 10968
diff changeset
   769
                # The "mode & lnkkind != lnkkind or self._checklink"
ca6cebd8734e dirstate: ignore symlinks when fs cannot handle them (issue1888)
Martin Geisler <mg@aragost.com>
parents: 10968
diff changeset
   770
                # lines are an expansion of "islink => checklink"
ca6cebd8734e dirstate: ignore symlinks when fs cannot handle them (issue1888)
Martin Geisler <mg@aragost.com>
parents: 10968
diff changeset
   771
                # where islink means "is this a link?" and checklink
ca6cebd8734e dirstate: ignore symlinks when fs cannot handle them (issue1888)
Martin Geisler <mg@aragost.com>
parents: 10968
diff changeset
   772
                # means "can we check links?".
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   773
                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
   774
                if (size >= 0 and
17733
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents: 17197
diff changeset
   775
                    ((size != st.st_size and size != st.st_size & _rangemask)
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
   776
                     or ((mode ^ st.st_mode) & 0100 and self._checkexec))
11769
ca6cebd8734e dirstate: ignore symlinks when fs cannot handle them (issue1888)
Martin Geisler <mg@aragost.com>
parents: 10968
diff changeset
   777
                    and (mode & lnkkind != lnkkind or self._checklink)
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   778
                    or size == -2 # other parent
4677
de8ec7e1753a dirstate.status: if a file is marked as copied, consider it modified
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4657
diff changeset
   779
                    or fn in self._copymap):
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   780
                    madd(fn)
17733
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents: 17197
diff changeset
   781
                elif ((time != mtime and time != mtime & _rangemask)
11769
ca6cebd8734e dirstate: ignore symlinks when fs cannot handle them (issue1888)
Martin Geisler <mg@aragost.com>
parents: 10968
diff changeset
   782
                      and (mode & lnkkind != lnkkind or self._checklink)):
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   783
                    ladd(fn)
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   784
                elif mtime == self._lastnormaltime:
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   785
                    # fn may have been changed in the same timeslot without
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   786
                    # changing its size. This can happen if we quickly do
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   787
                    # multiple commits in a single transaction.
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   788
                    # 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
   789
                    ladd(fn)
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
   790
                elif listclean:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   791
                    cadd(fn)
6590
9f80e062d71c status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents: 6589
diff changeset
   792
            elif state == 'm':
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   793
                madd(fn)
6590
9f80e062d71c status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents: 6589
diff changeset
   794
            elif state == 'a':
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   795
                aadd(fn)
6590
9f80e062d71c status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents: 6589
diff changeset
   796
            elif state == 'r':
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
   797
                radd(fn)
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
   798
2661
5c10b7ed3411 status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2486
diff changeset
   799
        return (lookup, modified, added, removed, deleted, unknown, ignored,
5c10b7ed3411 status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2486
diff changeset
   800
                clean)