mercurial/dirstate.py
author FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
Fri, 03 Jun 2016 00:44:20 +0900
changeset 29301 28f37ffc0a91
parent 29273 118a605e3ad9
child 29302 083e107adaac
permissions -rw-r--r--
dirstate: make writing dirstate file out avoid ambiguity of file stat Cached attribute repo.dirstate uses stat of '.hg/dirstate' file to examine validity of cached contents. If writing '.hg/dirstate' file out keeps ctime, mtime and size of it, change is overlooked, and old contents cached before change isn't invalidated as expected. To avoid ambiguity of file stat, this patch writes '.hg/dirstate' file out with checkambig=True. The former diff hunk changes the code path for "dirstate.write()", and the latter changes the code path for "dirstate.savebackup()". This patch is a part of "Exact Cache Validation Plan": https://www.mercurial-scm.org/wiki/ExactCacheValidationPlan
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
8226
8b2cd04a6e97 put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents: 8225
diff changeset
     1
# dirstate.py - working directory tracking for mercurial
8b2cd04a6e97 put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents: 8225
diff changeset
     2
#
8b2cd04a6e97 put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents: 8225
diff changeset
     3
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
8b2cd04a6e97 put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents: 8225
diff changeset
     4
#
8b2cd04a6e97 put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents: 8225
diff changeset
     5
# This software may be used and distributed according to the terms of the
10263
25e572394f5c Update license to GPLv2+
Matt Mackall <mpm@selenic.com>
parents: 9678
diff changeset
     6
# GNU General Public License version 2 or any later version.
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
     7
27503
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
     8
from __future__ import absolute_import
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
     9
27670
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
    10
import collections
27503
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    11
import errno
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    12
import os
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    13
import stat
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    14
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    15
from .i18n import _
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    16
from .node import nullid
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    17
from . import (
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    18
    encoding,
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    19
    error,
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    20
    match as matchmod,
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    21
    osutil,
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    22
    parsers,
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    23
    pathutil,
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    24
    scmutil,
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    25
    util,
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
    26
)
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
    27
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
    28
propertycache = util.propertycache
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    29
filecache = scmutil.filecache
17733
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents: 17197
diff changeset
    30
_rangemask = 0x7fffffff
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    31
21809
e250b8300e6e parsers: inline fields of dirstate values in C version
Siddharth Agarwal <sid0@fb.com>
parents: 21808
diff changeset
    32
dirstatetuple = parsers.dirstatetuple
21808
7537e57f5dbd dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents: 21116
diff changeset
    33
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    34
class repocache(filecache):
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    35
    """filecache for files in .hg/"""
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    36
    def join(self, obj, fname):
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
    37
        return obj._opener.join(fname)
4610
274c99fc629f dirstate: simplify state()
Matt Mackall <mpm@selenic.com>
parents: 4609
diff changeset
    38
16202
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    39
class rootcache(filecache):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    40
    """filecache for files in the repository root"""
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    41
    def join(self, obj, fname):
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    42
        return obj._join(fname)
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
    43
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
    44
def _getfsnow(vfs):
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
    45
    '''Get "now" timestamp on filesystem'''
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
    46
    tmpfd, tmpname = vfs.mkstemp()
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
    47
    try:
27016
448cbdab5883 util: drop statmtimesec
Matt Mackall <mpm@selenic.com>
parents: 26984
diff changeset
    48
        return os.fstat(tmpfd).st_mtime
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
    49
    finally:
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
    50
        os.close(tmpfd)
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
    51
        vfs.unlink(tmpname)
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
    52
27588
714849ba7836 dirstate: add a function to compute non-normal entries from the dmap
Laurent Charignon <lcharignon@fb.com>
parents: 27503
diff changeset
    53
def nonnormalentries(dmap):
714849ba7836 dirstate: add a function to compute non-normal entries from the dmap
Laurent Charignon <lcharignon@fb.com>
parents: 27503
diff changeset
    54
    '''Compute the nonnormal dirstate entries from the dmap'''
27593
bc97b9af4e62 dirstate: call the C implementation of nonnonormalentries when available
Laurent Charignon <lcharignon@fb.com>
parents: 27590
diff changeset
    55
    try:
bc97b9af4e62 dirstate: call the C implementation of nonnonormalentries when available
Laurent Charignon <lcharignon@fb.com>
parents: 27590
diff changeset
    56
        return parsers.nonnormalentries(dmap)
bc97b9af4e62 dirstate: call the C implementation of nonnonormalentries when available
Laurent Charignon <lcharignon@fb.com>
parents: 27590
diff changeset
    57
    except AttributeError:
bc97b9af4e62 dirstate: call the C implementation of nonnonormalentries when available
Laurent Charignon <lcharignon@fb.com>
parents: 27590
diff changeset
    58
        return set(fname for fname, e in dmap.iteritems()
bc97b9af4e62 dirstate: call the C implementation of nonnonormalentries when available
Laurent Charignon <lcharignon@fb.com>
parents: 27590
diff changeset
    59
                   if e[0] != 'n' or e[3] == -1)
27588
714849ba7836 dirstate: add a function to compute non-normal entries from the dmap
Laurent Charignon <lcharignon@fb.com>
parents: 27503
diff changeset
    60
26635
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    61
def _trypending(root, vfs, filename):
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    62
    '''Open  file to be read according to HG_PENDING environment variable
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    63
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    64
    This opens '.pending' of specified 'filename' only when HG_PENDING
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    65
    is equal to 'root'.
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    66
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    67
    This returns '(fp, is_pending_opened)' tuple.
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    68
    '''
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    69
    if root == os.environ.get('HG_PENDING'):
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    70
        try:
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    71
            return (vfs('%s.pending' % filename), True)
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    72
        except IOError as inst:
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    73
            if inst.errno != errno.ENOENT:
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    74
                raise
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    75
    return (vfs(filename), False)
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
    76
29150
0e9ed09f5fe9 cleanup: replace False identity testing with an explicit token object
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 29149
diff changeset
    77
_token = object()
0e9ed09f5fe9 cleanup: replace False identity testing with an explicit token object
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 29149
diff changeset
    78
1559
59b3639df0a9 Convert all classes to new-style classes by deriving them from object.
Eric Hopper <hopper@omnifarious.org>
parents: 1541
diff changeset
    79
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
    80
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 12907
diff changeset
    81
    def __init__(self, opener, ui, root, validate):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    82
        '''Create a new dirstate object.
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    83
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    84
        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
    85
        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
    86
        the dirstate.
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
    87
        '''
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
    88
        self._opener = opener
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 12907
diff changeset
    89
        self._validate = validate
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
    90
        self._root = root
24198
3cc630be5f09 dirstate: make sure rootdir ends with directory separator (issue4557)
Yuya Nishihara <yuya@tcha.org>
parents: 23866
diff changeset
    91
        # ntpath.join(root, '') of Python 2.7.9 does not add sep if root is
3cc630be5f09 dirstate: make sure rootdir ends with directory separator (issue4557)
Yuya Nishihara <yuya@tcha.org>
parents: 23866
diff changeset
    92
        # UNC path pointing to root share (issue4557)
24833
cb981009d697 dirstate: use pathutil.normasprefix to ensure os.sep at the end of root
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 24635
diff changeset
    93
        self._rootdir = pathutil.normasprefix(root)
26294
1ffc61c4e32e hgweb: overwrite cwd to resolve file patterns relative to repo (issue4568)
Yuya Nishihara <yuya@tcha.org>
parents: 26293
diff changeset
    94
        # internal config: ui.forcecwd
1ffc61c4e32e hgweb: overwrite cwd to resolve file patterns relative to repo (issue4568)
Yuya Nishihara <yuya@tcha.org>
parents: 26293
diff changeset
    95
        forcecwd = ui.config('ui', 'forcecwd')
1ffc61c4e32e hgweb: overwrite cwd to resolve file patterns relative to repo (issue4568)
Yuya Nishihara <yuya@tcha.org>
parents: 26293
diff changeset
    96
        if forcecwd:
1ffc61c4e32e hgweb: overwrite cwd to resolve file patterns relative to repo (issue4568)
Yuya Nishihara <yuya@tcha.org>
parents: 26293
diff changeset
    97
            self._cwd = forcecwd
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
    98
        self._dirty = False
4965
4106dde15aed Merge with crew
Matt Mackall <mpm@selenic.com>
parents: 4911 4953
diff changeset
    99
        self._dirtypl = False
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
   100
        self._lastnormaltime = 0
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   101
        self._ui = ui
16200
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16143
diff changeset
   102
        self._filecache = {}
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   103
        self._parentwriters = 0
25226
00d426a38137 dirstate: use self._filename instead of immediate string `dirstate`
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 25216
diff changeset
   104
        self._filename = 'dirstate'
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
   105
        self._pendingfilename = '%s.pending' % self._filename
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   106
26781
1aee2ab0f902 spelling: trivial spell checking
Mads Kiilerich <madski@unity3d.com>
parents: 26749
diff changeset
   107
        # for consistent view between _pl() and _read() invocations
26635
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
   108
        self._pendingmode = None
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
   109
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   110
    def beginparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   111
        '''Marks the beginning of a set of changes that involve changing
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   112
        the dirstate parents. If there is an exception during this time,
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   113
        the dirstate will not be written when the wlock is released. This
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   114
        prevents writing an incoherent dirstate where the parent doesn't
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   115
        match the contents.
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   116
        '''
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   117
        self._parentwriters += 1
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   118
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   119
    def endparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   120
        '''Marks the end of a set of changes that involve changing the
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   121
        dirstate parents. Once all parent changes have been marked done,
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   122
        the wlock will be free to write the dirstate on release.
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   123
        '''
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   124
        if self._parentwriters > 0:
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   125
            self._parentwriters -= 1
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   126
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   127
    def pendingparentchange(self):
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   128
        '''Returns true if the dirstate is in the middle of a set of changes
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   129
        that modify the dirstate parent.
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   130
        '''
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   131
        return self._parentwriters > 0
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
   132
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   133
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   134
    def _map(self):
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   135
        '''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
   136
        (state, mode, size, time).'''
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   137
        self._read()
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   138
        return self._map
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   139
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   140
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   141
    def _copymap(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   142
        self._read()
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   143
        return self._copymap
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   144
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   145
    @propertycache
27589
3e4f9d78ebd4 dirstate: attach the nonnormalset to a propertycache
Laurent Charignon <lcharignon@fb.com>
parents: 27588
diff changeset
   146
    def _nonnormalset(self):
3e4f9d78ebd4 dirstate: attach the nonnormalset to a propertycache
Laurent Charignon <lcharignon@fb.com>
parents: 27588
diff changeset
   147
        return nonnormalentries(self._map)
3e4f9d78ebd4 dirstate: attach the nonnormalset to a propertycache
Laurent Charignon <lcharignon@fb.com>
parents: 27588
diff changeset
   148
3e4f9d78ebd4 dirstate: attach the nonnormalset to a propertycache
Laurent Charignon <lcharignon@fb.com>
parents: 27588
diff changeset
   149
    @propertycache
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   150
    def _filefoldmap(self):
24610
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
   151
        try:
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
   152
            makefilefoldmap = parsers.make_file_foldmap
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
   153
        except AttributeError:
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
   154
            pass
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
   155
        else:
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
   156
            return makefilefoldmap(self._map, util.normcasespec,
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
   157
                                   util.normcasefallback)
4a4018831d2e dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents: 24561
diff changeset
   158
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   159
        f = {}
22782
a1eb21f5caea dirstate: cache util.normcase while constructing the foldmap
Siddharth Agarwal <sid0@fb.com>
parents: 22459
diff changeset
   160
        normcase = util.normcase
19103
0176d0db4671 icasefs: ignore removed files at building "dirstate._foldmap" up on icasefs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18899
diff changeset
   161
        for name, s in self._map.iteritems():
0176d0db4671 icasefs: ignore removed files at building "dirstate._foldmap" up on icasefs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18899
diff changeset
   162
            if s[0] != 'r':
22782
a1eb21f5caea dirstate: cache util.normcase while constructing the foldmap
Siddharth Agarwal <sid0@fb.com>
parents: 22459
diff changeset
   163
                f[normcase(name)] = name
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   164
        f['.'] = '.' # prevents useless util.fspath() invocation
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   165
        return f
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   166
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   167
    @propertycache
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   168
    def _dirfoldmap(self):
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   169
        f = {}
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   170
        normcase = util.normcase
16302
49b54f1ae053 dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents: 16258
diff changeset
   171
        for name in self._dirs:
22782
a1eb21f5caea dirstate: cache util.normcase while constructing the foldmap
Siddharth Agarwal <sid0@fb.com>
parents: 22459
diff changeset
   172
            f[normcase(name)] = name
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   173
        return f
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   174
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
   175
    @repocache('branch')
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   176
    def _branch(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   177
        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
   178
            return self._opener.read("branch").strip() or "default"
25660
328739ea70c3 global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25658
diff changeset
   179
        except IOError as inst:
15799
e43c140eb08f dirstate: propagate IOError other than ENOENT when reading branch
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15670
diff changeset
   180
            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
   181
                raise
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   182
            return "default"
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   183
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   184
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   185
    def _pl(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   186
        try:
26635
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
   187
            fp = self._opendirstatefile()
13400
14f3795a5ed7 explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 13343
diff changeset
   188
            st = fp.read(40)
14f3795a5ed7 explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 13343
diff changeset
   189
            fp.close()
8716
f3322bb29a0e dirstate: don't complain about 0-length files
Matt Mackall <mpm@selenic.com>
parents: 8708
diff changeset
   190
            l = len(st)
f3322bb29a0e dirstate: don't complain about 0-length files
Matt Mackall <mpm@selenic.com>
parents: 8708
diff changeset
   191
            if l == 40:
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   192
                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
   193
            elif l > 0 and l < 40:
26587
56b2bcea2529 error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26521
diff changeset
   194
                raise error.Abort(_('working directory state appears damaged!'))
25660
328739ea70c3 global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25658
diff changeset
   195
        except IOError as err:
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   196
            if err.errno != errno.ENOENT:
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   197
                raise
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   198
        return [nullid, nullid]
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   199
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   200
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   201
    def _dirs(self):
24635
21e1ece30f8c util: move dirs() and finddirs() from scmutil to util
Drew Gottlieb <drgott@google.com>
parents: 24632
diff changeset
   202
        return util.dirs(self._map, 'r')
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   203
16143
fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15801
diff changeset
   204
    def dirs(self):
fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15801
diff changeset
   205
        return self._dirs
fceb2964fa6c context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15801
diff changeset
   206
16202
53e2cd303ecf dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents: 16201
diff changeset
   207
    @rootcache('.hgignore')
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   208
    def _ignore(self):
27594
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   209
        files = self._ignorefiles()
25216
dc562165044a ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents: 25163
diff changeset
   210
        if not files:
dc562165044a ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents: 25163
diff changeset
   211
            return util.never
dc562165044a ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents: 25163
diff changeset
   212
dc562165044a ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents: 25163
diff changeset
   213
        pats = ['include:%s' % f for f in files]
dc562165044a ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents: 25163
diff changeset
   214
        return matchmod.match(self._root, '', [], pats, warn=self._ui.warn)
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   215
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   216
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   217
    def _slash(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   218
        return self._ui.configbool('ui', 'slash') and os.sep != '/'
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   219
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   220
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   221
    def _checklink(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   222
        return util.checklink(self._root)
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   223
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   224
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   225
    def _checkexec(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   226
        return util.checkexec(self._root)
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   227
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   228
    @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   229
    def _checkcase(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   230
        return not util.checkcase(self._join('.hg'))
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
   231
4905
fc61495ea9cf dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents: 4904
diff changeset
   232
    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
   233
        # 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
   234
        # 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
   235
        return self._rootdir + f
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
   236
15337
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   237
    def flagfunc(self, buildfallback):
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   238
        if self._checklink and self._checkexec:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   239
            def f(x):
18869
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   240
                try:
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   241
                    st = os.lstat(self._join(x))
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   242
                    if util.statislink(st):
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   243
                        return 'l'
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   244
                    if util.statisexec(st):
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   245
                        return 'x'
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   246
                except OSError:
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
   247
                    pass
15337
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   248
                return ''
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   249
            return f
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   250
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   251
        fallback = buildfallback()
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   252
        if self._checklink:
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   253
            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
   254
                if os.path.islink(self._join(x)):
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   255
                    return 'l'
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   256
                if 'x' in fallback(x):
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   257
                    return 'x'
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   258
                return ''
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   259
            return f
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   260
        if self._checkexec:
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   261
            def f(x):
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   262
                if 'l' in fallback(x):
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   263
                    return 'l'
14273
38af0f514134 rename util.is_exec to isexec
Adrian Buehlmann <adrian@cadifra.com>
parents: 14168
diff changeset
   264
                if util.isexec(self._join(x)):
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   265
                    return 'x'
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   266
                return ''
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   267
            return f
15337
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   268
        else:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
   269
            return fallback
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
   270
20335
e40520642e64 rebase: do not crash in panic when cwd disapear in the process (issue4121)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 20033
diff changeset
   271
    @propertycache
e40520642e64 rebase: do not crash in panic when cwd disapear in the process (issue4121)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 20033
diff changeset
   272
    def _cwd(self):
e40520642e64 rebase: do not crash in panic when cwd disapear in the process (issue4121)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 20033
diff changeset
   273
        return os.getcwd()
e40520642e64 rebase: do not crash in panic when cwd disapear in the process (issue4121)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 20033
diff changeset
   274
870
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
   275
    def getcwd(self):
26293
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents: 25877
diff changeset
   276
        '''Return the path from which a canonical path is calculated.
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents: 25877
diff changeset
   277
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents: 25877
diff changeset
   278
        This path should be used to resolve file patterns or to convert
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents: 25877
diff changeset
   279
        canonical paths back to file paths for display. It shouldn't be
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents: 25877
diff changeset
   280
        used to get real file paths. Use vfs functions instead.
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents: 25877
diff changeset
   281
        '''
20335
e40520642e64 rebase: do not crash in panic when cwd disapear in the process (issue4121)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 20033
diff changeset
   282
        cwd = self._cwd
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   283
        if cwd == self._root:
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   284
            return ''
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   285
        # 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
   286
        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
   287
        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
   288
            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
   289
        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
   290
            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
   291
        else:
c93562fb12cc Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4229
diff changeset
   292
            # 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
   293
            return cwd
870
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
   294
4525
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4507
diff changeset
   295
    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
   296
        if cwd is None:
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4507
diff changeset
   297
            cwd = self.getcwd()
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   298
        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
   299
        if self._slash:
19210
865beb849720 dirstate: don't overnormalize for ui.slash
Matt Mackall <mpm@selenic.com>
parents: 19128
diff changeset
   300
            return util.pconvert(path)
4527
b422b558015b Add ui.slash hgrc setting
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4525
diff changeset
   301
        return path
4525
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4507
diff changeset
   302
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   303
    def __getitem__(self, key):
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   304
        '''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
   305
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   306
        States are:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   307
          n  normal
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   308
          m  needs merging
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   309
          r  marked for removal
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   310
          a  marked for addition
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   311
          ?  not tracked
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
   312
        '''
4906
30847b8af7ca dirstate: add __contains__ and make __getitem__ more useful
Matt Mackall <mpm@selenic.com>
parents: 4905
diff changeset
   313
        return self._map.get(key, ("?",))[0]
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
   314
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
   315
    def __contains__(self, key):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   316
        return key in self._map
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   317
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   318
    def __iter__(self):
8209
a1a5a57efe90 replace util.sort with sorted built-in
Matt Mackall <mpm@selenic.com>
parents: 8151
diff changeset
   319
        for x in sorted(self._map):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   320
            yield x
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
   321
18792
10669e24eb6c completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents: 18760
diff changeset
   322
    def iteritems(self):
10669e24eb6c completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents: 18760
diff changeset
   323
        return self._map.iteritems()
10669e24eb6c completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents: 18760
diff changeset
   324
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
   325
    def parents(self):
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 12907
diff changeset
   326
        return [self._validate(p) for p in self._pl]
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
   327
13876
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   328
    def p1(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   329
        return self._validate(self._pl[0])
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   330
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   331
    def p2(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   332
        return self._validate(self._pl[1])
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
   333
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
   334
    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
   335
        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
   336
1062
6d5a62a549fa pep-0008 cleanup
benoit.boissinot@ens-lyon.fr
parents: 1040
diff changeset
   337
    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
   338
        """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
   339
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   340
        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
   341
        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
   342
        returned by the call.
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   343
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   344
        See localrepo.setparents()
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   345
        """
22407
d259322a394b dirstate: add exception when calling setparent without begin/end (API)
Durham Goode <durham@fb.com>
parents: 22404
diff changeset
   346
        if self._parentwriters == 0:
22459
0c7b018d3258 dirstate: copyedit exception for no beginparentchange call
Siddharth Agarwal <sid0@fb.com>
parents: 22407
diff changeset
   347
            raise ValueError("cannot set dirstate parent without "
0c7b018d3258 dirstate: copyedit exception for no beginparentchange call
Siddharth Agarwal <sid0@fb.com>
parents: 22407
diff changeset
   348
                             "calling dirstate.beginparentchange")
22407
d259322a394b dirstate: add exception when calling setparent without begin/end (API)
Durham Goode <durham@fb.com>
parents: 22404
diff changeset
   349
4965
4106dde15aed Merge with crew
Matt Mackall <mpm@selenic.com>
parents: 4911 4953
diff changeset
   350
        self._dirty = self._dirtypl = True
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   351
        oldp2 = self._pl[1]
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   352
        self._pl = p1, p2
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   353
        copies = {}
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   354
        if oldp2 != nullid and p2 == nullid:
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   355
            for f, s in self._map.iteritems():
22895
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
   356
                # Discard 'm' markers when moving away from a merge state
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   357
                if s[0] == 'm':
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   358
                    if f in self._copymap:
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   359
                        copies[f] = self._copymap[f]
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   360
                    self.normallookup(f)
22895
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
   361
                # Also fix up otherparent markers
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
   362
                elif s[0] == 'n' and s[2] == -2:
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
   363
                    if f in self._copymap:
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
   364
                        copies[f] = self._copymap[f]
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
   365
                    self.add(f)
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
   366
        return copies
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
   367
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
   368
    def setbranch(self, branch):
13047
6c375e07d673 branch: operate on branch names in local string space where possible
Matt Mackall <mpm@selenic.com>
parents: 13032
diff changeset
   369
        self._branch = encoding.fromlocal(branch)
16472
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   370
        f = self._opener('branch', 'w', atomictemp=True)
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   371
        try:
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   372
            f.write(self._branch + '\n')
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
   373
            f.close()
18317
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   374
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   375
            # make sure filecache has the correct stat info for _branch after
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   376
            # replacing the underlying file
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   377
            ce = self._filecache['_branch']
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   378
            if ce:
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
   379
                ce.refresh()
18076
3bc21f6daac4 dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents: 17984
diff changeset
   380
        except: # re-raises
3bc21f6daac4 dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents: 17984
diff changeset
   381
            f.discard()
3bc21f6daac4 dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents: 17984
diff changeset
   382
            raise
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
   383
26635
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
   384
    def _opendirstatefile(self):
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
   385
        fp, mode = _trypending(self._root, self._opener, self._filename)
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
   386
        if self._pendingmode is not None and self._pendingmode != mode:
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
   387
            fp.close()
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
   388
            raise error.Abort(_('working directory state may be '
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
   389
                                'changed parallelly'))
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
   390
        self._pendingmode = mode
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
   391
        return fp
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
   392
4615
9b00b73a5286 dirstate: hide some more internals
Matt Mackall <mpm@selenic.com>
parents: 4614
diff changeset
   393
    def _read(self):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   394
        self._map = {}
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   395
        self._copymap = {}
4607
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   396
        try:
26635
79d86ab65c9d dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26634
diff changeset
   397
            fp = self._opendirstatefile()
25227
fd0f919170d2 dirstate: use open/read of vfs(opener) explicitly instead of read
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 25226
diff changeset
   398
            try:
fd0f919170d2 dirstate: use open/read of vfs(opener) explicitly instead of read
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 25226
diff changeset
   399
                st = fp.read()
fd0f919170d2 dirstate: use open/read of vfs(opener) explicitly instead of read
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 25226
diff changeset
   400
            finally:
fd0f919170d2 dirstate: use open/read of vfs(opener) explicitly instead of read
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 25226
diff changeset
   401
                fp.close()
25660
328739ea70c3 global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25658
diff changeset
   402
        except IOError as err:
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   403
            if err.errno != errno.ENOENT:
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   404
                raise
4607
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   405
            return
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   406
        if not st:
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   407
            return
49dcac6ede26 dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents: 4606
diff changeset
   408
25585
868b7ee8b570 dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 25448
diff changeset
   409
        if util.safehasattr(parsers, 'dict_new_presized'):
868b7ee8b570 dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 25448
diff changeset
   410
            # Make an estimate of the number of files in the dirstate based on
868b7ee8b570 dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 25448
diff changeset
   411
            # its size. From a linear regression on a set of real-world repos,
868b7ee8b570 dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 25448
diff changeset
   412
            # all over 10,000 files, the size of a dirstate entry is 85
868b7ee8b570 dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 25448
diff changeset
   413
            # bytes. The cost of resizing is significantly higher than the cost
868b7ee8b570 dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 25448
diff changeset
   414
            # of filling in a larger presized dict, so subtract 20% from the
868b7ee8b570 dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 25448
diff changeset
   415
            # size.
868b7ee8b570 dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 25448
diff changeset
   416
            #
868b7ee8b570 dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 25448
diff changeset
   417
            # This heuristic is imperfect in many ways, so in a future dirstate
868b7ee8b570 dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 25448
diff changeset
   418
            # format update it makes sense to just record the number of entries
868b7ee8b570 dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 25448
diff changeset
   419
            # on write.
868b7ee8b570 dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 25448
diff changeset
   420
            self._map = parsers.dict_new_presized(len(st) / 71)
868b7ee8b570 dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 25448
diff changeset
   421
18649
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   422
        # Python's garbage collector triggers a GC each time a certain number
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   423
        # of container objects (the number being defined by
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   424
        # gc.get_threshold()) are allocated. parse_dirstate creates a tuple
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   425
        # for each file in the dirstate. The C version then immediately marks
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   426
        # them as not to be tracked by the collector. However, this has no
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   427
        # effect on when GCs are triggered, only on what objects the GC looks
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   428
        # into. This means that O(number of files) GCs are unavoidable.
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   429
        # Depending on when in the process's lifetime the dirstate is parsed,
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   430
        # this can get very expensive. As a workaround, disable GC while
0969980308c7 dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents: 18567
diff changeset
   431
        # parsing the dirstate.
23496
ee5a4ed4c8b1 dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23375
diff changeset
   432
        #
ee5a4ed4c8b1 dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23375
diff changeset
   433
        # (we cannot decorate the function directly since it is in a C module)
ee5a4ed4c8b1 dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23375
diff changeset
   434
        parse_dirstate = util.nogc(parsers.parse_dirstate)
ee5a4ed4c8b1 dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23375
diff changeset
   435
        p = parse_dirstate(self._map, self._copymap, st)
4952
a11921d24ec4 add dirstate._dirtypl variable
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4677
diff changeset
   436
        if not self._dirtypl:
7093
16bafcebd3d1 dirstate: C parsing extension
Matt Mackall <mpm@selenic.com>
parents: 7069
diff changeset
   437
            self._pl = p
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
   438
4613
3a645af7fb76 localrepo and dirstate: rename reload to invalidate
Matt Mackall <mpm@selenic.com>
parents: 4612
diff changeset
   439
    def invalidate(self):
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   440
        for a in ("_map", "_copymap", "_filefoldmap", "_dirfoldmap", "_branch",
27590
f2d0ada00257 dirstate: add code to update the non-normal set
Laurent Charignon <lcharignon@fb.com>
parents: 27589
diff changeset
   441
                  "_pl", "_dirs", "_ignore", "_nonnormalset"):
4953
6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4952
diff changeset
   442
            if a in self.__dict__:
6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4952
diff changeset
   443
                delattr(self, a)
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
   444
        self._lastnormaltime = 0
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
   445
        self._dirty = False
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
   446
        self._parentwriters = 0
4375
109077e7048d When reloading the dirstate, recompute ignore information if needed.
Bryan O'Sullivan <bos@serpentine.com>
parents: 4374
diff changeset
   447
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
   448
    def copy(self, source, dest):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   449
        """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
   450
        if source == dest:
deda205a00e1 Ignore dummy copies in dirstate and localrepo.filecommit()
Patrick Mezard <pmezard@gmail.com>
parents: 6479
diff changeset
   451
            return
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
   452
        self._dirty = True
7566
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents: 7280
diff changeset
   453
        if source is not None:
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents: 7280
diff changeset
   454
            self._copymap[dest] = source
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents: 7280
diff changeset
   455
        elif dest in self._copymap:
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents: 7280
diff changeset
   456
            del self._copymap[dest]
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
   457
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
   458
    def copied(self, file):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   459
        return self._copymap.get(file, None)
3154
b1f10d3223c1 dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents: 2962
diff changeset
   460
b1f10d3223c1 dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents: 2962
diff changeset
   461
    def copies(self):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   462
        return self._copymap
515
03f27b1381f9 Whitespace cleanups
mpm@selenic.com
parents: 514
diff changeset
   463
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   464
    def _droppath(self, f):
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   465
        if self[f] not in "?r" and "_dirs" in self.__dict__:
18899
d8ff607ef721 scmutil: use new dirs class in dirstate and context
Bryan O'Sullivan <bryano@fb.com>
parents: 18897
diff changeset
   466
            self._dirs.delpath(f)
2953
3d5547845158 fix issue 322.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2859
diff changeset
   467
26887
663eff02a876 dirstate: fix filefoldmap incosistency on file delete
Mateusz Kwapich <mitrandir@fb.com>
parents: 26782
diff changeset
   468
        if "_filefoldmap" in self.__dict__:
663eff02a876 dirstate: fix filefoldmap incosistency on file delete
Mateusz Kwapich <mitrandir@fb.com>
parents: 26782
diff changeset
   469
            normed = util.normcase(f)
663eff02a876 dirstate: fix filefoldmap incosistency on file delete
Mateusz Kwapich <mitrandir@fb.com>
parents: 26782
diff changeset
   470
            if normed in self._filefoldmap:
663eff02a876 dirstate: fix filefoldmap incosistency on file delete
Mateusz Kwapich <mitrandir@fb.com>
parents: 26782
diff changeset
   471
                del self._filefoldmap[normed]
663eff02a876 dirstate: fix filefoldmap incosistency on file delete
Mateusz Kwapich <mitrandir@fb.com>
parents: 26782
diff changeset
   472
17196
2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents: 17094
diff changeset
   473
    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
   474
        oldstate = self[f]
17196
2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents: 17094
diff changeset
   475
        if state == 'a' or oldstate == 'r':
13974
23f2736abce3 move checkfilename from util to scmutil
Adrian Buehlmann <adrian@cadifra.com>
parents: 13944
diff changeset
   476
            scmutil.checkfilename(f)
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   477
            if f in self._dirs:
26587
56b2bcea2529 error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26521
diff changeset
   478
                raise error.Abort(_('directory %r already in dirstate') % f)
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   479
            # shadows
24635
21e1ece30f8c util: move dirs() and finddirs() from scmutil to util
Drew Gottlieb <drgott@google.com>
parents: 24632
diff changeset
   480
            for d in util.finddirs(f):
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   481
                if d in self._dirs:
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   482
                    break
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   483
                if d in self._map and self[d] != 'r':
26587
56b2bcea2529 error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26521
diff changeset
   484
                    raise error.Abort(
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   485
                        _('file %r in dirstate clashes with %r') % (d, f))
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   486
        if oldstate in "?r" and "_dirs" in self.__dict__:
18899
d8ff607ef721 scmutil: use new dirs class in dirstate and context
Bryan O'Sullivan <bryano@fb.com>
parents: 18897
diff changeset
   487
            self._dirs.addpath(f)
17094
c2016bae3b97 dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents: 16955
diff changeset
   488
        self._dirty = True
21808
7537e57f5dbd dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents: 21116
diff changeset
   489
        self._map[f] = dirstatetuple(state, mode, size, mtime)
27590
f2d0ada00257 dirstate: add code to update the non-normal set
Laurent Charignon <lcharignon@fb.com>
parents: 27589
diff changeset
   490
        if state != 'n' or mtime == -1:
f2d0ada00257 dirstate: add code to update the non-normal set
Laurent Charignon <lcharignon@fb.com>
parents: 27589
diff changeset
   491
            self._nonnormalset.add(f)
5487
7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660).
Maxim Dounin <mdounin@mdounin.ru>
parents: 5396
diff changeset
   492
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   493
    def normal(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   494
        '''Mark a file normal and clean.'''
4905
fc61495ea9cf dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents: 4904
diff changeset
   495
        s = os.lstat(self._join(f))
27016
448cbdab5883 util: drop statmtimesec
Matt Mackall <mpm@selenic.com>
parents: 26984
diff changeset
   496
        mtime = s.st_mtime
17733
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents: 17197
diff changeset
   497
        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
   498
                      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
   499
        if f in self._copymap:
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   500
            del self._copymap[f]
27590
f2d0ada00257 dirstate: add code to update the non-normal set
Laurent Charignon <lcharignon@fb.com>
parents: 27589
diff changeset
   501
        if f in self._nonnormalset:
f2d0ada00257 dirstate: add code to update the non-normal set
Laurent Charignon <lcharignon@fb.com>
parents: 27589
diff changeset
   502
            self._nonnormalset.remove(f)
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   503
        if mtime > self._lastnormaltime:
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   504
            # 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
   505
            # 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
   506
            # modifications that happen within the same timeslot.
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
   507
            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
   508
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
   509
    def normallookup(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   510
        '''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
   511
        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
   512
            # 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
   513
            # 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
   514
            # 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
   515
            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
   516
            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
   517
                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
   518
                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
   519
                    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
   520
                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
   521
                    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
   522
                if source:
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   523
                    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
   524
                return
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
   525
            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
   526
                return
17094
c2016bae3b97 dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents: 16955
diff changeset
   527
        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
   528
        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
   529
            del self._copymap[f]
27590
f2d0ada00257 dirstate: add code to update the non-normal set
Laurent Charignon <lcharignon@fb.com>
parents: 27589
diff changeset
   530
        if f in self._nonnormalset:
f2d0ada00257 dirstate: add code to update the non-normal set
Laurent Charignon <lcharignon@fb.com>
parents: 27589
diff changeset
   531
            self._nonnormalset.remove(f)
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
   532
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   533
    def otherparent(self, f):
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   534
        '''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
   535
        if self._pl[1] == nullid:
26587
56b2bcea2529 error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26521
diff changeset
   536
            raise error.Abort(_("setting %r to other parent "
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   537
                               "only allowed in merges") % f)
22896
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   538
        if f in self and self[f] == 'n':
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   539
            # merge-like
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   540
            self._addpath(f, 'm', 0, -2, -1)
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   541
        else:
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   542
            # add-like
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   543
            self._addpath(f, 'n', 0, -2, -1)
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
   544
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   545
        if f in self._copymap:
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   546
            del self._copymap[f]
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   547
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   548
    def add(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   549
        '''Mark a file added.'''
17196
2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents: 17094
diff changeset
   550
        self._addpath(f, 'a', 0, -1, -1)
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   551
        if f in self._copymap:
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   552
            del self._copymap[f]
4616
70352337934e dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents: 4615
diff changeset
   553
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   554
    def remove(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   555
        '''Mark a file removed.'''
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   556
        self._dirty = True
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   557
        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
   558
        size = 0
fed1a9c22076 dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6257
diff changeset
   559
        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
   560
            # 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
   561
            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
   562
            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
   563
                size = -1
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
   564
            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
   565
                size = -2
21808
7537e57f5dbd dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents: 21116
diff changeset
   566
        self._map[f] = dirstatetuple('r', 0, size, 0)
27590
f2d0ada00257 dirstate: add code to update the non-normal set
Laurent Charignon <lcharignon@fb.com>
parents: 27589
diff changeset
   567
        self._nonnormalset.add(f)
6297
fed1a9c22076 dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6257
diff changeset
   568
        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
   569
            del self._copymap[f]
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   570
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   571
    def merge(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
   572
        '''Mark a file merged.'''
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   573
        if self._pl[1] == nullid:
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
   574
            return self.normallookup(f)
22897
8fe74328f700 dirstate: merge falls through to otherparent
Matt Mackall <mpm@selenic.com>
parents: 22896
diff changeset
   575
        return self.otherparent(f)
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
   576
14434
cc8c09855d19 dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents: 14273
diff changeset
   577
    def drop(self, f):
cc8c09855d19 dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents: 14273
diff changeset
   578
        '''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
   579
        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
   580
            self._dirty = True
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents: 15337
diff changeset
   581
            self._droppath(f)
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents: 15337
diff changeset
   582
            del self._map[f]
27590
f2d0ada00257 dirstate: add code to update the non-normal set
Laurent Charignon <lcharignon@fb.com>
parents: 27589
diff changeset
   583
            if f in self._nonnormalset:
f2d0ada00257 dirstate: add code to update the non-normal set
Laurent Charignon <lcharignon@fb.com>
parents: 27589
diff changeset
   584
                self._nonnormalset.remove(f)
29247
3e438497edca dirstate: remove file from copymap on drop
Mateusz Kwapich <mitrandir@fb.com>
parents: 29189
diff changeset
   585
            if f in self._copymap:
3e438497edca dirstate: remove file from copymap on drop
Mateusz Kwapich <mitrandir@fb.com>
parents: 29189
diff changeset
   586
                del self._copymap[f]
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   587
24538
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   588
    def _discoverpath(self, path, normed, ignoremissing, exists, storemap):
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   589
        if exists is None:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   590
            exists = os.path.lexists(os.path.join(self._root, path))
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   591
        if not exists:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   592
            # Maybe a path component exists
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   593
            if not ignoremissing and '/' in path:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   594
                d, f = path.rsplit('/', 1)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   595
                d = self._normalize(d, False, ignoremissing, None)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   596
                folded = d + "/" + f
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   597
            else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   598
                # No path components, preserve original case
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   599
                folded = path
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   600
        else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   601
            # recursively normalize leading directory components
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   602
            # against dirstate
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   603
            if '/' in normed:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   604
                d, f = normed.rsplit('/', 1)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   605
                d = self._normalize(d, False, ignoremissing, True)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   606
                r = self._root + "/" + d
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   607
                folded = d + "/" + util.fspath(f, r)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   608
            else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   609
                folded = util.fspath(normed, self._root)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   610
            storemap[normed] = folded
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   611
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   612
        return folded
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   613
24539
3a8eba78803e dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents: 24538
diff changeset
   614
    def _normalizefile(self, path, isknown, ignoremissing=False, exists=None):
15488
6eff984d8e76 dirstate: fix case-folding identity for traditional Unix
Matt Mackall <mpm@selenic.com>
parents: 15399
diff changeset
   615
        normed = util.normcase(path)
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   616
        folded = self._filefoldmap.get(normed, None)
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   617
        if folded is None:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   618
            if isknown:
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   619
                folded = path
7068
57377fa7eda2 issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents: 7034
diff changeset
   620
            else:
24539
3a8eba78803e dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents: 24538
diff changeset
   621
                folded = self._discoverpath(path, normed, ignoremissing, exists,
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   622
                                            self._filefoldmap)
24539
3a8eba78803e dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents: 24538
diff changeset
   623
        return folded
16302
49b54f1ae053 dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents: 16258
diff changeset
   624
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   625
    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
   626
        normed = util.normcase(path)
24561
6514030dc686 dirstate._normalize: don't construct dirfoldmap if not necessary
Siddharth Agarwal <sid0@fb.com>
parents: 24560
diff changeset
   627
        folded = self._filefoldmap.get(normed, None)
6514030dc686 dirstate._normalize: don't construct dirfoldmap if not necessary
Siddharth Agarwal <sid0@fb.com>
parents: 24560
diff changeset
   628
        if folded is None:
6514030dc686 dirstate._normalize: don't construct dirfoldmap if not necessary
Siddharth Agarwal <sid0@fb.com>
parents: 24560
diff changeset
   629
            folded = self._dirfoldmap.get(normed, None)
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   630
        if folded is None:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   631
            if isknown:
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   632
                folded = path
7068
57377fa7eda2 issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents: 7034
diff changeset
   633
            else:
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   634
                # store discovered result in dirfoldmap so that future
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   635
                # normalizefile calls don't start matching directories
24538
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
   636
                folded = self._discoverpath(path, normed, ignoremissing, exists,
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
   637
                                            self._dirfoldmap)
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   638
        return folded
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   639
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   640
    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
   641
        '''
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   642
        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
   643
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   644
        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
   645
        disk, to avoid extra filesystem access.
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   646
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   647
        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
   648
        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
   649
        existing path components.
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   650
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   651
        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
   652
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   653
        - 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
   654
        - version of name stored on disk
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   655
        - version provided via command arguments
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   656
        '''
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   657
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   658
        if self._checkcase:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
   659
            return self._normalize(path, isknown, ignoremissing)
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
   660
        return path
6677
9865e15febd0 Add a normalize() method to dirstate
Paul Moore <p.f.moore@gmail.com>
parents: 6675
diff changeset
   661
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   662
    def clear(self):
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   663
        self._map = {}
27590
f2d0ada00257 dirstate: add code to update the non-normal set
Laurent Charignon <lcharignon@fb.com>
parents: 27589
diff changeset
   664
        self._nonnormalset = set()
5487
7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660).
Maxim Dounin <mdounin@mdounin.ru>
parents: 5396
diff changeset
   665
        if "_dirs" in self.__dict__:
10394
4612cded5176 fix coding style (reported by pylint)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10282
diff changeset
   666
            delattr(self, "_dirs")
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   667
        self._copymap = {}
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   668
        self._pl = [nullid, nullid]
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
   669
        self._lastnormaltime = 0
5123
79373ec3f27d merge with crew-stable
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5045 5065
diff changeset
   670
        self._dirty = True
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
   671
18760
e74704c33e24 strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents: 18663
diff changeset
   672
    def rebuild(self, parent, allfiles, changedfiles=None):
25448
2bbfc2042d93 dirstate: avoid invalidating every entries when list is empty
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25275
diff changeset
   673
        if changedfiles is None:
27176
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   674
            # Rebuild entire dirstate
25448
2bbfc2042d93 dirstate: avoid invalidating every entries when list is empty
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25275
diff changeset
   675
            changedfiles = allfiles
27176
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   676
            lastnormaltime = self._lastnormaltime
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   677
            self.clear()
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   678
            self._lastnormaltime = lastnormaltime
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   679
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   680
        for f in changedfiles:
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   681
            mode = 0o666
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   682
            if f in allfiles and 'x' in allfiles.flags(f):
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   683
                mode = 0o777
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   684
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   685
            if f in allfiles:
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   686
                self._map[f] = dirstatetuple('n', mode, -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
   687
            else:
27176
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   688
                self._map.pop(f, None)
27590
f2d0ada00257 dirstate: add code to update the non-normal set
Laurent Charignon <lcharignon@fb.com>
parents: 27589
diff changeset
   689
                if f in self._nonnormalset:
f2d0ada00257 dirstate: add code to update the non-normal set
Laurent Charignon <lcharignon@fb.com>
parents: 27589
diff changeset
   690
                    self._nonnormalset.remove(f)
27176
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
   691
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
   692
        self._pl = (parent, nullid)
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
   693
        self._dirty = True
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   694
29150
0e9ed09f5fe9 cleanup: replace False identity testing with an explicit token object
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 29149
diff changeset
   695
    def write(self, tr=_token):
4612
17ee7407097f dirstate: simplify dirty handling
Matt Mackall <mpm@selenic.com>
parents: 4611
diff changeset
   696
        if not self._dirty:
1794
98b6c1cad58b only write the dirstate when something changed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1755
diff changeset
   697
            return
21931
89b809fa6cef dirstate: delay writing out to ensure timestamp of each entries explicitly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 21810
diff changeset
   698
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   699
        filename = self._filename
29150
0e9ed09f5fe9 cleanup: replace False identity testing with an explicit token object
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 29149
diff changeset
   700
        if tr is _token: # not explicitly specified
29149
2e40fada340b devel: officially deprecate dirstate.write without transaction argument
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 29137
diff changeset
   701
            self._ui.deprecwarn('use dirstate.write with '
29097
ff4cc44364e3 devel: use the new 'config' argument for the dirstate develwarn
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 27670
diff changeset
   702
                               'repo.currenttransaction()',
29149
2e40fada340b devel: officially deprecate dirstate.write without transaction argument
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 29137
diff changeset
   703
                               '3.9')
26749
4a82cb5c1dc8 dirstate: show develwarn for write() invocation without transaction
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26747
diff changeset
   704
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   705
            if self._opener.lexists(self._pendingfilename):
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   706
                # if pending file already exists, in-memory changes
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   707
                # should be written into it, because it has priority
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   708
                # to '.hg/dirstate' at reading under HG_PENDING mode
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   709
                filename = self._pendingfilename
26747
beff0b2481b3 dirstate: remove layering violation around writing dirstate out
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26746
diff changeset
   710
        elif tr:
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   711
            # 'dirstate.write()' is not only for writing in-memory
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   712
            # changes out, but also for dropping ambiguous timestamp.
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   713
            # delayed writing re-raise "ambiguous timestamp issue".
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   714
            # See also the wiki page below for detail:
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   715
            # https://www.mercurial-scm.org/wiki/DirstateTransactionPlan
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   716
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   717
            # emulate dropping timestamp in 'parsers.pack_dirstate'
26747
beff0b2481b3 dirstate: remove layering violation around writing dirstate out
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26746
diff changeset
   718
            now = _getfsnow(self._opener)
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   719
            dmap = self._map
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   720
            for f, e in dmap.iteritems():
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   721
                if e[0] == 'n' and e[3] == now:
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   722
                    dmap[f] = dirstatetuple(e[0], e[1], e[2], -1)
27590
f2d0ada00257 dirstate: add code to update the non-normal set
Laurent Charignon <lcharignon@fb.com>
parents: 27589
diff changeset
   723
                    self._nonnormalset.add(f)
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   724
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   725
            # emulate that all 'dirstate.normal' results are written out
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   726
            self._lastnormaltime = 0
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   727
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   728
            # delay writing in-memory changes out
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   729
            tr.addfilegenerator('dirstate', (self._filename,),
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   730
                                self._writedirstate, location='plain')
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   731
            return
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
   732
29301
28f37ffc0a91 dirstate: make writing dirstate file out avoid ambiguity of file stat
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 29273
diff changeset
   733
        st = self._opener(filename, "w", atomictemp=True, checkambig=True)
26521
3f41e28a16d8 dirstate: split write to write changes into files other than .hg/dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26492
diff changeset
   734
        self._writedirstate(st)
3f41e28a16d8 dirstate: split write to write changes into files other than .hg/dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26492
diff changeset
   735
3f41e28a16d8 dirstate: split write to write changes into files other than .hg/dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26492
diff changeset
   736
    def _writedirstate(self, st):
9509
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
   737
        # 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
   738
        # filesystem's notion of 'now'
27016
448cbdab5883 util: drop statmtimesec
Matt Mackall <mpm@selenic.com>
parents: 26984
diff changeset
   739
        now = util.fstat(st).st_mtime & _rangemask
27397
6c6b48aca328 dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents: 27176
diff changeset
   740
6c6b48aca328 dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents: 27176
diff changeset
   741
        # enough 'delaywrite' prevents 'pack_dirstate' from dropping
6c6b48aca328 dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents: 27176
diff changeset
   742
        # timestamp of each entries in dirstate, because of 'now > mtime'
6c6b48aca328 dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents: 27176
diff changeset
   743
        delaywrite = self._ui.configint('debug', 'dirstate.delaywrite', 0)
6c6b48aca328 dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents: 27176
diff changeset
   744
        if delaywrite > 0:
27398
c81675776c95 dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents: 27397
diff changeset
   745
            # do we have any files to delay for?
c81675776c95 dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents: 27397
diff changeset
   746
            for f, e in self._map.iteritems():
c81675776c95 dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents: 27397
diff changeset
   747
                if e[0] == 'n' and e[3] == now:
c81675776c95 dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents: 27397
diff changeset
   748
                    import time # to avoid useless import
27399
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
   749
                    # rather than sleep n seconds, sleep until the next
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
   750
                    # multiple of n seconds
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
   751
                    clock = time.time()
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
   752
                    start = int(clock) - (int(clock) % delaywrite)
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
   753
                    end = start + delaywrite
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
   754
                    time.sleep(end - clock)
27398
c81675776c95 dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents: 27397
diff changeset
   755
                    break
27397
6c6b48aca328 dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents: 27176
diff changeset
   756
21026
7ee03e190c1d dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents: 20632
diff changeset
   757
        st.write(parsers.pack_dirstate(self._map, self._copymap, self._pl, now))
27590
f2d0ada00257 dirstate: add code to update the non-normal set
Laurent Charignon <lcharignon@fb.com>
parents: 27589
diff changeset
   758
        self._nonnormalset = nonnormalentries(self._map)
21026
7ee03e190c1d dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents: 20632
diff changeset
   759
        st.close()
7ee03e190c1d dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents: 20632
diff changeset
   760
        self._lastnormaltime = 0
7ee03e190c1d dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents: 20632
diff changeset
   761
        self._dirty = self._dirtypl = False
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   762
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   763
    def _dirignore(self, f):
6479
31abcae33b4f dirstate: do not ignore current directory '.' (issue 1078)
Patrick Mezard <pmezard@gmail.com>
parents: 6327
diff changeset
   764
        if f == '.':
31abcae33b4f dirstate: do not ignore current directory '.' (issue 1078)
Patrick Mezard <pmezard@gmail.com>
parents: 6327
diff changeset
   765
            return False
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   766
        if self._ignore(f):
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   767
            return True
24635
21e1ece30f8c util: move dirs() and finddirs() from scmutil to util
Drew Gottlieb <drgott@google.com>
parents: 24632
diff changeset
   768
        for p in util.finddirs(f):
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
   769
            if self._ignore(p):
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   770
                return True
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   771
        return False
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
   772
27594
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   773
    def _ignorefiles(self):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   774
        files = []
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   775
        if os.path.exists(self._join('.hgignore')):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   776
            files.append(self._join('.hgignore'))
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   777
        for name, path in self._ui.configitems("ui"):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   778
            if name == 'ignore' or name.startswith('ignore.'):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   779
                # we need to use os.path.join here rather than self._join
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   780
                # because path is arbitrary and user-specified
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   781
                files.append(os.path.join(self._rootdir, util.expandpath(path)))
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   782
        return files
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
   783
27670
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   784
    def _ignorefileandline(self, f):
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   785
        files = collections.deque(self._ignorefiles())
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   786
        visited = set()
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   787
        while files:
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   788
            i = files.popleft()
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   789
            patterns = matchmod.readpatternfile(i, self._ui.warn,
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   790
                                                sourceinfo=True)
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   791
            for pattern, lineno, line in patterns:
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   792
                kind, p = matchmod._patsplit(pattern, 'glob')
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   793
                if kind == "subinclude":
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   794
                    if p not in visited:
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   795
                        files.append(p)
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   796
                    continue
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   797
                m = matchmod.match(self._root, '', [], [pattern],
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   798
                                   warn=self._ui.warn)
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   799
                if m(f):
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   800
                    return (i, lineno, line)
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   801
            visited.add(i)
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   802
        return (None, -1, "")
4374f039d269 dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents: 27594
diff changeset
   803
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   804
    def _walkexplicit(self, match, subrepos):
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   805
        '''Get stat data about the files explicitly specified by match.
3529
09d99b7e4da0 simplify dirstate walking
Matt Mackall <mpm@selenic.com>
parents: 3223
diff changeset
   806
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   807
        Return a triple (results, dirsfound, dirsnotfound).
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   808
        - results is a mapping from filename to stat result. It also contains
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   809
          listings mapping subrepos and .hg to None.
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   810
        - dirsfound is a list of files found to be directories.
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   811
        - dirsnotfound is a list of files that the dirstate thinks are
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   812
          directories and that were not found.'''
6578
f242d3684f83 walk: begin refactoring badmatch handling
Matt Mackall <mpm@selenic.com>
parents: 6577
diff changeset
   813
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
   814
        def badtype(mode):
8310
8417d82d3969 dirstate: translate forgotten string
Simon Heimberg <simohe@besonet.ch>
parents: 8261
diff changeset
   815
            kind = _('unknown')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   816
            if stat.S_ISCHR(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   817
                kind = _('character device')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   818
            elif stat.S_ISBLK(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   819
                kind = _('block device')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   820
            elif stat.S_ISFIFO(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   821
                kind = _('fifo')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   822
            elif stat.S_ISSOCK(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   823
                kind = _('socket')
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   824
            elif stat.S_ISDIR(mode):
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   825
                kind = _('directory')
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
   826
            return _('unsupported file type (type is %s)') % kind
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   827
19142
c3d3e4d75ec3 dirstate.walk: cache match.explicitdir and traversedir locally
Siddharth Agarwal <sid0@fb.com>
parents: 19137
diff changeset
   828
        matchedir = match.explicitdir
8676
acd69fc201a5 walk: we always have a badfn
Matt Mackall <mpm@selenic.com>
parents: 8675
diff changeset
   829
        badfn = match.bad
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   830
        dmap = self._map
5000
46facb73ba8b dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents: 4965
diff changeset
   831
        lstat = os.lstat
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   832
        getkind = stat.S_IFMT
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
   833
        dirkind = stat.S_IFDIR
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   834
        regkind = stat.S_IFREG
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   835
        lnkkind = stat.S_IFLNK
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   836
        join = self._join
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   837
        dirsfound = []
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   838
        foundadd = dirsfound.append
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   839
        dirsnotfound = []
19175
63f7bd2e1a46 dirstate._walkexplicit: inline dirsnotfound.append
Siddharth Agarwal <sid0@fb.com>
parents: 19174
diff changeset
   840
        notfoundadd = dirsnotfound.append
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   841
24448
55c449345b10 match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents: 24212
diff changeset
   842
        if not match.isexact() and self._checkcase:
12907
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
   843
            normalize = self._normalize
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
   844
        else:
18032
a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents: 18018
diff changeset
   845
            normalize = None
12907
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
   846
12211
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   847
        files = sorted(match.files())
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   848
        subrepos.sort()
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   849
        i, j = 0, 0
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   850
        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
   851
            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
   852
            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
   853
                i += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   854
                continue
13339
22167be007ed subrepo: fix pruning of subrepo filenames in dirstate (issue2619)
trbs <trbs@trbs.net>
parents: 13233
diff changeset
   855
            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
   856
                del files[i]
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   857
            j += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   858
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   859
        if not files or '.' in files:
24521
489026bffbf6 dirstate._walkexplicit: indicate root as '.', not ''
Siddharth Agarwal <sid0@fb.com>
parents: 24448
diff changeset
   860
            files = ['.']
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
   861
        results = dict.fromkeys(subrepos)
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
   862
        results['.hg'] = None
5000
46facb73ba8b dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents: 4965
diff changeset
   863
23375
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
   864
        alldirs = None
12211
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
   865
        for ff in files:
24523
a4b81dbe73c1 dirstate._walkexplicit: don't bother normalizing '.'
Siddharth Agarwal <sid0@fb.com>
parents: 24522
diff changeset
   866
            # constructing the foldmap is expensive, so don't do it for the
a4b81dbe73c1 dirstate._walkexplicit: don't bother normalizing '.'
Siddharth Agarwal <sid0@fb.com>
parents: 24522
diff changeset
   867
            # common case where files is ['.']
a4b81dbe73c1 dirstate._walkexplicit: don't bother normalizing '.'
Siddharth Agarwal <sid0@fb.com>
parents: 24522
diff changeset
   868
            if normalize and ff != '.':
24522
18085e46caa9 dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents: 24521
diff changeset
   869
                nf = normalize(ff, False, True)
18032
a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents: 18018
diff changeset
   870
            else:
24522
18085e46caa9 dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents: 24521
diff changeset
   871
                nf = ff
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
   872
            if nf in results:
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   873
                continue
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   874
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   875
            try:
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
   876
                st = lstat(join(nf))
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   877
                kind = getkind(st.st_mode)
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   878
                if kind == dirkind:
8588
2624f485b9bc dirstate: set more states in step 1 of walk
Simon Heimberg <simohe@besonet.ch>
parents: 8521
diff changeset
   879
                    if nf in dmap:
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   880
                        # file replaced by dir on disk but still in dirstate
8588
2624f485b9bc dirstate: set more states in step 1 of walk
Simon Heimberg <simohe@besonet.ch>
parents: 8521
diff changeset
   881
                        results[nf] = None
19143
3cb9468535bd match: make explicitdir and traversedir None by default
Siddharth Agarwal <sid0@fb.com>
parents: 19142
diff changeset
   882
                    if matchedir:
3cb9468535bd match: make explicitdir and traversedir None by default
Siddharth Agarwal <sid0@fb.com>
parents: 19142
diff changeset
   883
                        matchedir(nf)
24537
2bb13f2b778c dirstate: don't require exact case when adding dirs on icasefs (issue4578)
Matt Harbison <matt_harbison@yahoo.com>
parents: 24198
diff changeset
   884
                    foundadd((nf, ff))
12401
4cdaf1adafc8 backout most of 4f8067c94729
Matt Mackall <mpm@selenic.com>
parents: 12387
diff changeset
   885
                elif kind == regkind or kind == lnkkind:
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   886
                    results[nf] = st
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
   887
                else:
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
   888
                    badfn(ff, badtype(kind))
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
   889
                    if nf in dmap:
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
   890
                        results[nf] = None
25660
328739ea70c3 global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25658
diff changeset
   891
            except OSError as inst: # nf not found on disk - it is dirstate only
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   892
                if nf in dmap: # does it exactly match a missing file?
8675
fb74e1e69da0 walk: simplify check for missing file
Matt Mackall <mpm@selenic.com>
parents: 8645
diff changeset
   893
                    results[nf] = None
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   894
                else: # does it match a missing directory?
23375
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
   895
                    if alldirs is None:
24635
21e1ece30f8c util: move dirs() and finddirs() from scmutil to util
Drew Gottlieb <drgott@google.com>
parents: 24632
diff changeset
   896
                        alldirs = util.dirs(dmap)
23375
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
   897
                    if nf in alldirs:
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
   898
                        if matchedir:
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
   899
                            matchedir(nf)
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
   900
                        notfoundadd(nf)
8677
34df078b8b1b walk: simplify logic for badfn clause
Matt Mackall <mpm@selenic.com>
parents: 8676
diff changeset
   901
                    else:
8680
b6511055d37b match: ignore return of match.bad
Matt Mackall <mpm@selenic.com>
parents: 8677
diff changeset
   902
                        badfn(ff, inst.strerror)
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
   903
25877
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   904
        # Case insensitive filesystems cannot rely on lstat() failing to detect
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   905
        # a case-only rename.  Prune the stat object for any file that does not
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   906
        # match the case in the filesystem, if there are multiple files that
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   907
        # normalize to the same path.
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   908
        if match.isexact() and self._checkcase:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   909
            normed = {}
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   910
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   911
            for f, st in results.iteritems():
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   912
                if st is None:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   913
                    continue
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   914
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   915
                nc = util.normcase(f)
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   916
                paths = normed.get(nc)
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   917
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   918
                if paths is None:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   919
                    paths = set()
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   920
                    normed[nc] = paths
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   921
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   922
                paths.add(f)
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   923
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   924
            for norm, paths in normed.iteritems():
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   925
                if len(paths) > 1:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   926
                    for path in paths:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   927
                        folded = self._discoverpath(path, norm, True, None,
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   928
                                                    self._dirfoldmap)
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   929
                        if path != folded:
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   930
                            results[path] = None
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
   931
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
   932
        return results, dirsfound, dirsnotfound
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   933
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
   934
    def walk(self, match, subrepos, unknown, ignored, full=True):
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   935
        '''
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   936
        Walk recursively through the directory tree, finding all files
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   937
        matched by match.
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   938
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
   939
        If full is False, maybe skip some known-clean files.
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
   940
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   941
        Return a dict mapping filename to stat-like object (either
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   942
        mercurial.osutil.stat instance or return value of os.stat()).
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
   943
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   944
        '''
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
   945
        # full is a flag that extensions that hook into walk can use -- this
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
   946
        # implementation doesn't use it at all. This satisfies the contract
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
   947
        # because we only guarantee a "maybe".
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   948
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   949
        if ignored:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   950
            ignore = util.never
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   951
            dirignore = util.never
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   952
        elif unknown:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   953
            ignore = self._ignore
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   954
            dirignore = self._dirignore
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   955
        else:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
   956
            # if not unknown and not ignored, drop dir recursion and step 2
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   957
            ignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   958
            dirignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   959
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   960
        matchfn = match.matchfn
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   961
        matchalways = match.always()
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   962
        matchtdir = match.traversedir
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   963
        dmap = self._map
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   964
        listdir = osutil.listdir
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   965
        lstat = os.lstat
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   966
        dirkind = stat.S_IFDIR
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   967
        regkind = stat.S_IFREG
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   968
        lnkkind = stat.S_IFLNK
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   969
        join = self._join
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   970
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   971
        exact = skipstep3 = False
24448
55c449345b10 match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents: 24212
diff changeset
   972
        if match.isexact(): # match.exact
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   973
            exact = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   974
            dirignore = util.always # skip step 2
25234
3c346969c321 dirstate: avoid match.files() in walk()
Martin von Zweigbergk <martinvonz@google.com>
parents: 25227
diff changeset
   975
        elif match.prefix(): # match.match, no patterns
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   976
            skipstep3 = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   977
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   978
        if not exact and self._checkcase:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   979
            normalize = self._normalize
24541
e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents: 24540
diff changeset
   980
            normalizefile = self._normalizefile
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   981
            skipstep3 = False
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   982
        else:
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   983
            normalize = self._normalize
24541
e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents: 24540
diff changeset
   984
            normalizefile = None
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   985
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   986
        # step 1: find all explicit files
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   987
        results, work, dirsnotfound = self._walkexplicit(match, subrepos)
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
   988
19172
c6cea2e2031b dirstate.walk: pull skipstep3 out of the explicit walk code
Siddharth Agarwal <sid0@fb.com>
parents: 19171
diff changeset
   989
        skipstep3 = skipstep3 and not (work or dirsnotfound)
24537
2bb13f2b778c dirstate: don't require exact case when adding dirs on icasefs (issue4578)
Matt Harbison <matt_harbison@yahoo.com>
parents: 24198
diff changeset
   990
        work = [d for d in work if not dirignore(d[0])]
19171
252de7b77cfd dirstate.walk: move dirignore filter out of explicit walk code
Siddharth Agarwal <sid0@fb.com>
parents: 19170
diff changeset
   991
6826
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents: 6825
diff changeset
   992
        # step 2: visit subdirectories
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   993
        def traverse(work, alreadynormed):
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   994
            wadd = work.append
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   995
            while work:
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
   996
                nd = work.pop()
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   997
                skip = None
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   998
                if nd == '.':
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
   999
                    nd = ''
18032
a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents: 18018
diff changeset
  1000
                else:
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1001
                    skip = '.hg'
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1002
                try:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1003
                    entries = listdir(join(nd), stat=True, skip=skip)
25660
328739ea70c3 global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25658
diff changeset
  1004
                except OSError as inst:
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1005
                    if inst.errno in (errno.EACCES, errno.ENOENT):
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1006
                        match.bad(self.pathto(nd), inst.strerror)
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1007
                        continue
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1008
                    raise
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1009
                for f, kind, st in entries:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1010
                    if normalizefile:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1011
                        # even though f might be a directory, we're only
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1012
                        # interested in comparing it to files currently in the
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1013
                        # dmap -- therefore normalizefile is enough
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1014
                        nf = normalizefile(nd and (nd + "/" + f) or f, True,
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1015
                                           True)
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1016
                    else:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1017
                        nf = nd and (nd + "/" + f) or f
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1018
                    if nf not in results:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1019
                        if kind == dirkind:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1020
                            if not ignore(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1021
                                if matchtdir:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1022
                                    matchtdir(nf)
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1023
                                wadd(nf)
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1024
                            if nf in dmap and (matchalways or matchfn(nf)):
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1025
                                results[nf] = None
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1026
                        elif kind == regkind or kind == lnkkind:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1027
                            if nf in dmap:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1028
                                if matchalways or matchfn(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1029
                                    results[nf] = st
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1030
                            elif ((matchalways or matchfn(nf))
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1031
                                  and not ignore(nf)):
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1032
                                # unknown file -- normalize if necessary
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1033
                                if not alreadynormed:
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1034
                                    nf = normalize(nf, False, True)
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1035
                                results[nf] = st
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1036
                        elif nf in dmap and (matchalways or matchfn(nf)):
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
  1037
                            results[nf] = None
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
  1038
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1039
        for nd, d in work:
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1040
            # alreadynormed means that processwork doesn't have to do any
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1041
            # expensive directory normalization
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1042
            alreadynormed = not normalize or nd == d
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
  1043
            traverse([d], alreadynormed)
536
c15b4bc0a11c Refactor diffrevs/diffdir into changes
mpm@selenic.com
parents: 529
diff changeset
  1044
18812
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18792
diff changeset
  1045
        for s in subrepos:
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18792
diff changeset
  1046
            del results[s]
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18792
diff changeset
  1047
        del results['.hg']
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18792
diff changeset
  1048
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
  1049
        # step 3: visit remaining files from dmap
8684
5bb7780b57c7 match: fold plan cases down to two special cases
Matt Mackall <mpm@selenic.com>
parents: 8683
diff changeset
  1050
        if not skipstep3 and not exact:
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
  1051
            # If a dmap file is not in results yet, it was either
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
  1052
            # a) not matching matchfn b) ignored, c) missing, or d) under a
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
  1053
            # symlink directory.
18815
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
  1054
            if not results and matchalways:
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
  1055
                visit = dmap.keys()
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
  1056
            else:
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
  1057
                visit = [f for f in dmap if f not in results and matchfn(f)]
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
  1058
            visit.sort()
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
  1059
18625
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1060
            if unknown:
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
  1061
                # unknown == True means we walked all dirs under the roots
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
  1062
                # that wasn't ignored, and everything that matched was stat'ed
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
  1063
                # and is already in results.
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
  1064
                # The rest must thus be ignored or under a symlink.
20033
f962870712da pathutil: tease out a new library to break an import cycle from canonpath use
Augie Fackler <raf@durin42.com>
parents: 19910
diff changeset
  1065
                audit_path = pathutil.pathauditor(self._root)
18625
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1066
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1067
                for nf in iter(visit):
24621
1784ca148392 dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents: 24537
diff changeset
  1068
                    # If a stat for the same file was already added with a
1784ca148392 dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents: 24537
diff changeset
  1069
                    # different case, don't add one for this, since that would
1784ca148392 dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents: 24537
diff changeset
  1070
                    # make it appear as if the file exists under both names
1784ca148392 dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents: 24537
diff changeset
  1071
                    # on disk.
24632
b2fb1403994e merge with stable
Matt Mackall <mpm@selenic.com>
parents: 24610 24621
diff changeset
  1072
                    if (normalizefile and
b2fb1403994e merge with stable
Matt Mackall <mpm@selenic.com>
parents: 24610 24621
diff changeset
  1073
                        normalizefile(nf, True, True) in results):
24621
1784ca148392 dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents: 24537
diff changeset
  1074
                        results[nf] = None
18625
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1075
                    # Report ignored items in the dmap as long as they are not
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1076
                    # under a symlink directory.
24621
1784ca148392 dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents: 24537
diff changeset
  1077
                    elif audit_path.check(nf):
18663
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
  1078
                        try:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
  1079
                            results[nf] = lstat(join(nf))
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
  1080
                            # file was just ignored, no links, and exists
18663
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
  1081
                        except OSError:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
  1082
                            # file doesn't exist
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
  1083
                            results[nf] = None
18625
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1084
                    else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1085
                        # It's either missing or under a symlink directory
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
  1086
                        # which we in this case report as missing
18625
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1087
                        results[nf] = None
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1088
            else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1089
                # We may not have walked the full directory tree above,
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
  1090
                # so stat and check everything we missed.
18625
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
  1091
                nf = iter(visit).next
26984
af2663680e95 dirstate: back out 502b56a9e897
Bryan O'Sullivan <bos@serpentine.com>
parents: 26887
diff changeset
  1092
                for st in util.statfiles([join(i) for i in visit]):
af2663680e95 dirstate: back out 502b56a9e897
Bryan O'Sullivan <bos@serpentine.com>
parents: 26887
diff changeset
  1093
                    results[nf()] = st
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
  1094
        return results
669
8aa2a282eda4 .hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents: 667
diff changeset
  1095
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
  1096
    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
  1097
        '''Determine the status of the working copy relative to the
22915
4d680deb0d9e status: update and move documentation of status types to status class
Martin von Zweigbergk <martinvonz@gmail.com>
parents: 22913
diff changeset
  1098
        dirstate and return a pair of (unsure, status), where status is of type
4d680deb0d9e status: update and move documentation of status types to status class
Martin von Zweigbergk <martinvonz@gmail.com>
parents: 22913
diff changeset
  1099
        scmutil.status and:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1100
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1101
          unsure:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1102
            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
  1103
            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
  1104
            but mtime differs)
22915
4d680deb0d9e status: update and move documentation of status types to status class
Martin von Zweigbergk <martinvonz@gmail.com>
parents: 22913
diff changeset
  1105
          status.modified:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1106
            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
  1107
            was written (different size or mode)
22915
4d680deb0d9e status: update and move documentation of status types to status class
Martin von Zweigbergk <martinvonz@gmail.com>
parents: 22913
diff changeset
  1108
          status.clean:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1109
            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
  1110
            dirstate was written
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1111
        '''
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
  1112
        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
  1113
        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
  1114
        removed, deleted, clean = [], [], []
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
  1115
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1116
        dmap = self._map
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
  1117
        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
  1118
        madd = modified.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1119
        aadd = added.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1120
        uadd = unknown.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1121
        iadd = ignored.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1122
        radd = removed.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1123
        dadd = deleted.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1124
        cadd = clean.append
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1125
        mexact = match.exact
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1126
        dirignore = self._dirignore
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1127
        checkexec = self._checkexec
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1128
        copymap = self._copymap
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1129
        lastnormaltime = self._lastnormaltime
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1130
19191
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
  1131
        # We need to do full walks when either
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
  1132
        # - we're listing all clean files, or
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
  1133
        # - match.traversedir does something, because match.traversedir should
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
  1134
        #   be called for every dir in the working dir
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
  1135
        full = listclean or match.traversedir is not None
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
  1136
        for fn, st in self.walk(match, subrepos, listunknown, listignored,
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
  1137
                                full=full).iteritems():
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
  1138
            if fn not in dmap:
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1139
                if (listignored or mexact(fn)) and dirignore(fn):
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
  1140
                    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
  1141
                        iadd(fn)
19910
601944f41257 dirstate.status: return explicit unknown files even when not asked
Siddharth Agarwal <sid0@fb.com>
parents: 19651
diff changeset
  1142
                else:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1143
                    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
  1144
                continue
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
  1145
21810
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1146
            # This is equivalent to 'state, mode, size, time = dmap[fn]' but not
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1147
            # written like that for performance reasons. dmap[fn] is not a
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1148
            # Python tuple in compiled builds. The CPython UNPACK_SEQUENCE
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1149
            # opcode has fast paths when the value to be unpacked is a tuple or
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1150
            # a list, but falls back to creating a full-fledged iterator in
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1151
            # general. That is much slower than simply accessing and storing the
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1152
            # tuple members one by one.
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1153
            t = dmap[fn]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1154
            state = t[0]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1155
            mode = t[1]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1156
            size = t[2]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
  1157
            time = t[3]
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
  1158
6818
6e93fbd847ef dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents: 6811
diff changeset
  1159
            if not st and state in "nma":
6e93fbd847ef dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents: 6811
diff changeset
  1160
                dadd(fn)
6e93fbd847ef dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents: 6811
diff changeset
  1161
            elif state == 'n':
6257
bfd49ce0db64 dirstate: ignore mode changes if the fs does not supports the exec bit
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6212
diff changeset
  1162
                if (size >= 0 and
17733
3c775c5a6c03 dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents: 17197
diff changeset
  1163
                    ((size != st.st_size and size != st.st_size & _rangemask)
25658
e93036747902 global: mass rewrite to use modern octal syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25585
diff changeset
  1164
                     or ((mode ^ st.st_mode) & 0o100 and checkexec))
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
  1165
                    or size == -2 # other parent
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
  1166
                    or fn in copymap):
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1167
                    madd(fn)
27016
448cbdab5883 util: drop statmtimesec
Matt Mackall <mpm@selenic.com>
parents: 26984
diff changeset
  1168
                elif time != st.st_mtime and time != st.st_mtime & _rangemask:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1169
                    ladd(fn)
27016
448cbdab5883 util: drop statmtimesec
Matt Mackall <mpm@selenic.com>
parents: 26984
diff changeset
  1170
                elif st.st_mtime == lastnormaltime:
24181
5245caa0dcde dirstate: clarify comment about leaving normal files undef if changed 'now'
Mads Kiilerich <madski@unity3d.com>
parents: 23866
diff changeset
  1171
                    # fn may have just been marked as normal and it may have
5245caa0dcde dirstate: clarify comment about leaving normal files undef if changed 'now'
Mads Kiilerich <madski@unity3d.com>
parents: 23866
diff changeset
  1172
                    # changed in the same second without changing its size.
5245caa0dcde dirstate: clarify comment about leaving normal files undef if changed 'now'
Mads Kiilerich <madski@unity3d.com>
parents: 23866
diff changeset
  1173
                    # This can happen if we quickly do multiple commits.
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
  1174
                    # 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
  1175
                    ladd(fn)
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
  1176
                elif listclean:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1177
                    cadd(fn)
6590
9f80e062d71c status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents: 6589
diff changeset
  1178
            elif state == 'm':
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1179
                madd(fn)
6590
9f80e062d71c status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents: 6589
diff changeset
  1180
            elif state == 'a':
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1181
                aadd(fn)
6590
9f80e062d71c status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents: 6589
diff changeset
  1182
            elif state == 'r':
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
  1183
                radd(fn)
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
  1184
22913
cb4449921a1d status: create class for status lists
Martin von Zweigbergk <martinvonz@gmail.com>
parents: 22911
diff changeset
  1185
        return (lookup, scmutil.status(modified, added, removed, deleted,
cb4449921a1d status: create class for status lists
Martin von Zweigbergk <martinvonz@gmail.com>
parents: 22911
diff changeset
  1186
                                       unknown, ignored, clean))
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1187
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1188
    def matches(self, match):
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1189
        '''
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1190
        return files in the dirstate (in whatever state) filtered by match
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1191
        '''
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1192
        dmap = self._map
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1193
        if match.always():
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1194
            return dmap.keys()
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1195
        files = match.files()
24448
55c449345b10 match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents: 24212
diff changeset
  1196
        if match.isexact():
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1197
            # fast path -- filter the other way around, since typically files is
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1198
            # much smaller than dmap
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1199
            return [f for f in files if f in dmap]
25275
d94e403b5237 dirstate: use match.prefix() instead of 'not match.anypats()'
Martin von Zweigbergk <martinvonz@google.com>
parents: 25234
diff changeset
  1200
        if match.prefix() and all(fn in dmap for fn in files):
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1201
            # fast path -- all the values are known to be files, so just return
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1202
            # that
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1203
            return list(files)
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
  1204
        return [f for f in dmap if match(f)]
26632
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26630
diff changeset
  1205
26746
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
  1206
    def _actualfilename(self, tr):
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
  1207
        if tr:
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1208
            return self._pendingfilename
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1209
        else:
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1210
            return self._filename
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1211
29189
930d4ee4647e dirstate: add prefix and suffix arguments to backup
Mateusz Kwapich <mitrandir@fb.com>
parents: 29150
diff changeset
  1212
    def savebackup(self, tr, suffix='', prefix=''):
26632
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26630
diff changeset
  1213
        '''Save current dirstate into backup file with suffix'''
29273
118a605e3ad9 distate: add assertions to backup functions
Mateusz Kwapich <mitrandir@fb.com>
parents: 29269
diff changeset
  1214
        assert len(suffix) > 0 or len(prefix) > 0
26746
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
  1215
        filename = self._actualfilename(tr)
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1216
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1217
        # use '_writedirstate' instead of 'write' to write changes certainly,
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1218
        # because the latter omits writing out if transaction is running.
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1219
        # output file will be used to create backup of dirstate at this point.
29301
28f37ffc0a91 dirstate: make writing dirstate file out avoid ambiguity of file stat
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 29273
diff changeset
  1220
        self._writedirstate(self._opener(filename, "w", atomictemp=True,
28f37ffc0a91 dirstate: make writing dirstate file out avoid ambiguity of file stat
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 29273
diff changeset
  1221
                                         checkambig=True))
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1222
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1223
        if tr:
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1224
            # ensure that subsequent tr.writepending returns True for
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1225
            # changes written out above, even if dirstate is never
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1226
            # changed after this
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1227
            tr.addfilegenerator('dirstate', (self._filename,),
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1228
                                self._writedirstate, location='plain')
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1229
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1230
            # ensure that pending file written above is unlinked at
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1231
            # failure, even if tr.writepending isn't invoked until the
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1232
            # end of this transaction
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1233
            tr.registertmp(filename, location='plain')
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
  1234
29269
b6f9934cf10b dirstate: don't use actualfilename to name the backup file
Mateusz Kwapich <mitrandir@fb.com>
parents: 29247
diff changeset
  1235
        self._opener.write(prefix + self._filename + suffix,
29189
930d4ee4647e dirstate: add prefix and suffix arguments to backup
Mateusz Kwapich <mitrandir@fb.com>
parents: 29150
diff changeset
  1236
                           self._opener.tryread(filename))
26632
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26630
diff changeset
  1237
29189
930d4ee4647e dirstate: add prefix and suffix arguments to backup
Mateusz Kwapich <mitrandir@fb.com>
parents: 29150
diff changeset
  1238
    def restorebackup(self, tr, suffix='', prefix=''):
26632
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26630
diff changeset
  1239
        '''Restore dirstate by backup file with suffix'''
29273
118a605e3ad9 distate: add assertions to backup functions
Mateusz Kwapich <mitrandir@fb.com>
parents: 29269
diff changeset
  1240
        assert len(suffix) > 0 or len(prefix) > 0
26632
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26630
diff changeset
  1241
        # this "invalidate()" prevents "wlock.release()" from writing
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26630
diff changeset
  1242
        # changes of dirstate out after restoring from backup file
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26630
diff changeset
  1243
        self.invalidate()
26746
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
  1244
        filename = self._actualfilename(tr)
29269
b6f9934cf10b dirstate: don't use actualfilename to name the backup file
Mateusz Kwapich <mitrandir@fb.com>
parents: 29247
diff changeset
  1245
        # using self._filename to avoid having "pending" in the backup filename
b6f9934cf10b dirstate: don't use actualfilename to name the backup file
Mateusz Kwapich <mitrandir@fb.com>
parents: 29247
diff changeset
  1246
        self._opener.rename(prefix + self._filename + suffix, filename)
26632
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26630
diff changeset
  1247
29189
930d4ee4647e dirstate: add prefix and suffix arguments to backup
Mateusz Kwapich <mitrandir@fb.com>
parents: 29150
diff changeset
  1248
    def clearbackup(self, tr, suffix='', prefix=''):
26632
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26630
diff changeset
  1249
        '''Clear backup file with suffix'''
29273
118a605e3ad9 distate: add assertions to backup functions
Mateusz Kwapich <mitrandir@fb.com>
parents: 29269
diff changeset
  1250
        assert len(suffix) > 0 or len(prefix) > 0
29269
b6f9934cf10b dirstate: don't use actualfilename to name the backup file
Mateusz Kwapich <mitrandir@fb.com>
parents: 29247
diff changeset
  1251
        # using self._filename to avoid having "pending" in the backup filename
b6f9934cf10b dirstate: don't use actualfilename to name the backup file
Mateusz Kwapich <mitrandir@fb.com>
parents: 29247
diff changeset
  1252
        self._opener.unlink(prefix + self._filename + suffix)