mercurial/localrepo.py
author Pierre-Yves David <pierre-yves.david@fb.com>
Thu, 17 Apr 2014 15:27:54 -0400
changeset 21144 7a20fe8dc080
parent 21141 d8dd19e09ed4
child 21145 0c5088be66af
permissions -rw-r--r--
bundle2: use HG2X in the header The current implementation of bundle2 is still very experimental and the 3.0 freeze is yesterday. The current bundle2 format has never been field-tested, so we rename the header to HG2X. This leaves the HG20 header available for real usage as a stable format in Mercurial 3.1. We won't guarantee that future mercurial versions will keep supporting this `HG2X` format.
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1089
142b5d5ec9cc Break apart hg.py
mpm@selenic.com
parents: 1072
diff changeset
     1
# localrepo.py - read/write repository class for mercurial
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
     2
#
4635
63b9d2deed48 Updated copyright notices and add "and others" to "hg version"
Thomas Arendsen Hein <thomas@intevation.de>
parents: 4633
diff changeset
     3
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
     4
#
8225
46293a0c7e9f updated license to be explicit about GPL version 2
Martin Geisler <mg@lazybytes.net>
parents: 8210
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: 9954
diff changeset
     6
# GNU General Public License version 2 or any later version.
18118
e70ff1e599f4 branchmap: extract read logic from repo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18117
diff changeset
     7
from node import hex, nullid, short
3891
6b4127c7d52a Simplify i18n imports
Matt Mackall <mpm@selenic.com>
parents: 3877
diff changeset
     8
from i18n import _
21141
d8dd19e09ed4 bundle2: advertise bundle2 caps in server capabilities
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21140
diff changeset
     9
import urllib
20930
4a987060d97e localrepo: move the getbundle method in changegroup module
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20928
diff changeset
    10
import peer, changegroup, subrepo, pushkey, obsolete, repoview
15418
cf729af26963 phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15403
diff changeset
    11
import changelog, dirstate, filelog, manifest, context, bookmarks, phases
20088
7cbb79bddee7 localrepo: import "lock" module as "lockmod" for readability
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20087
diff changeset
    12
import lock as lockmod
21068
c15b66a6bbb4 bundle2: return a stream from exchange.getbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21043
diff changeset
    13
import transaction, store, encoding, exchange, bundle2
14902
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
    14
import scmutil, util, extensions, hook, error, revset
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
    15
import match as matchmod
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
    16
import merge as mergemod
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
    17
import tags as tagsmod
8109
496ae1ea4698 switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8108
diff changeset
    18
from lock import release
11303
a1aad8333864 move working dir/dirstate methods from localrepo to workingctx
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 11301
diff changeset
    19
import weakref, errno, os, time, inspect
20033
f962870712da pathutil: tease out a new library to break an import cycle from canonpath use
Augie Fackler <raf@durin42.com>
parents: 20027
diff changeset
    20
import branchmap, pathutil
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
    21
propertycache = util.propertycache
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
    22
filecache = scmutil.filecache
8109
496ae1ea4698 switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8108
diff changeset
    23
18014
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    24
class repofilecache(filecache):
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    25
    """All filecache usage on repo are done for logic that should be unfiltered
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    26
    """
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    27
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    28
    def __get__(self, repo, type=None):
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    29
        return super(repofilecache, self).__get__(repo.unfiltered(), type)
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    30
    def __set__(self, repo, value):
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    31
        return super(repofilecache, self).__set__(repo.unfiltered(), value)
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    32
    def __delete__(self, repo):
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    33
        return super(repofilecache, self).__delete__(repo.unfiltered())
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    34
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
    35
class storecache(repofilecache):
16198
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
    36
    """filecache for files in the store"""
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
    37
    def join(self, obj, fname):
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
    38
        return obj.sjoin(fname)
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
    39
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    40
class unfilteredpropertycache(propertycache):
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    41
    """propertycache that apply to unfiltered repo only"""
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    42
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    43
    def __get__(self, repo, type=None):
19846
9789670992d6 repoview: have unfilteredpropertycache using the underlying cache
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 19515
diff changeset
    44
        unfi = repo.unfiltered()
9789670992d6 repoview: have unfilteredpropertycache using the underlying cache
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 19515
diff changeset
    45
        if unfi is repo:
9789670992d6 repoview: have unfilteredpropertycache using the underlying cache
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 19515
diff changeset
    46
            return super(unfilteredpropertycache, self).__get__(unfi)
9789670992d6 repoview: have unfilteredpropertycache using the underlying cache
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 19515
diff changeset
    47
        return getattr(unfi, self.name)
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    48
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    49
class filteredpropertycache(propertycache):
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    50
    """propertycache that must take filtering in account"""
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    51
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    52
    def cachevalue(self, obj, value):
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    53
        object.__setattr__(obj, self.name, value)
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    54
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    55
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    56
def hasunfilteredcache(repo, name):
18644
3e92772d5383 spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents: 18520
diff changeset
    57
    """check if a repo has an unfilteredpropertycache value for <name>"""
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    58
    return name in vars(repo.unfiltered())
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
    59
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
    60
def unfilteredmethod(orig):
17994
8899bf48116a clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17993
diff changeset
    61
    """decorate method that always need to be run on unfiltered version"""
8899bf48116a clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17993
diff changeset
    62
    def wrapper(repo, *args, **kwargs):
8899bf48116a clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17993
diff changeset
    63
        return orig(repo.unfiltered(), *args, **kwargs)
8899bf48116a clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17993
diff changeset
    64
    return wrapper
8899bf48116a clfilter: introduce an `unfilteredmethod` decorator
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17993
diff changeset
    65
20955
12f161f08d74 bundle2: allow pulling changegroups using bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20954
diff changeset
    66
moderncaps = set(('lookup', 'branchmap', 'pushkey', 'known', 'getbundle',
21141
d8dd19e09ed4 bundle2: advertise bundle2 caps in server capabilities
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21140
diff changeset
    67
                  'unbundle'))
20776
d00c731f4637 localrepo: rename capability set to lower case.
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20773
diff changeset
    68
legacycaps = moderncaps.union(set(['changegroupsubset']))
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    69
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    70
class localpeer(peer.peerrepository):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    71
    '''peer for a local repo; reflects only the most recent API'''
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    72
20776
d00c731f4637 localrepo: rename capability set to lower case.
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20773
diff changeset
    73
    def __init__(self, repo, caps=moderncaps):
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    74
        peer.peerrepository.__init__(self)
18382
f3b21beb9802 filtering: rename filters to their antonyms
Kevin Bullock <kbullock@ringworld.org>
parents: 18364
diff changeset
    75
        self._repo = repo.filtered('served')
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    76
        self.ui = repo.ui
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    77
        self._caps = repo._restrictcapabilities(caps)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    78
        self.requirements = repo.requirements
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    79
        self.supportedformats = repo.supportedformats
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    80
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    81
    def close(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    82
        self._repo.close()
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    83
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    84
    def _capabilities(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    85
        return self._caps
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    86
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    87
    def local(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    88
        return self._repo
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    89
17193
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17192
diff changeset
    90
    def canpush(self):
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17192
diff changeset
    91
        return True
1d710fe5ee0e peer: introduce canpush and improve error message
Sune Foldager <cryo@cyanite.org>
parents: 17192
diff changeset
    92
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    93
    def url(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    94
        return self._repo.url()
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    95
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    96
    def lookup(self, key):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    97
        return self._repo.lookup(key)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    98
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
    99
    def branchmap(self):
18279
679767c38cb5 clfilter: drop extra filtering in localpeer
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18278
diff changeset
   100
        return self._repo.branchmap()
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   101
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   102
    def heads(self):
18279
679767c38cb5 clfilter: drop extra filtering in localpeer
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18278
diff changeset
   103
        return self._repo.heads()
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   104
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   105
    def known(self, nodes):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   106
        return self._repo.known(nodes)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   107
20953
8d853cad6b14 localpeer: propagate bundlecaps in getbundle call
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20933
diff changeset
   108
    def getbundle(self, source, heads=None, common=None, bundlecaps=None,
8d853cad6b14 localpeer: propagate bundlecaps in getbundle call
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20933
diff changeset
   109
                  format='HG10'):
21068
c15b66a6bbb4 bundle2: return a stream from exchange.getbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21043
diff changeset
   110
        cg = exchange.getbundle(self._repo, source, heads=heads,
c15b66a6bbb4 bundle2: return a stream from exchange.getbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21043
diff changeset
   111
                                common=common, bundlecaps=bundlecaps)
21144
7a20fe8dc080 bundle2: use HG2X in the header
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21141
diff changeset
   112
        if bundlecaps is not None and 'HG2X' in bundlecaps:
21068
c15b66a6bbb4 bundle2: return a stream from exchange.getbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21043
diff changeset
   113
            # When requesting a bundle2, getbundle returns a stream to make the
c15b66a6bbb4 bundle2: return a stream from exchange.getbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21043
diff changeset
   114
            # wire level function happier. We need to build a proper object
c15b66a6bbb4 bundle2: return a stream from exchange.getbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21043
diff changeset
   115
            # from it in local peer.
c15b66a6bbb4 bundle2: return a stream from exchange.getbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21043
diff changeset
   116
            cg = bundle2.unbundle20(self.ui, cg)
c15b66a6bbb4 bundle2: return a stream from exchange.getbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21043
diff changeset
   117
        return cg
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   118
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   119
    # TODO We might want to move the next two calls into legacypeer and add
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   120
    # unbundle instead.
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   121
20969
7a679918ee2b localrepo: add unbundle support
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20963
diff changeset
   122
    def unbundle(self, cg, heads, url):
7a679918ee2b localrepo: add unbundle support
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20963
diff changeset
   123
        """apply a bundle on a repo
7a679918ee2b localrepo: add unbundle support
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20963
diff changeset
   124
7a679918ee2b localrepo: add unbundle support
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20963
diff changeset
   125
        This function handles the repo locking itself."""
7a679918ee2b localrepo: add unbundle support
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20963
diff changeset
   126
        try:
21070
408877d491fb bundle2: feed a binary stream to `peer.unbundle`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21068
diff changeset
   127
            cg = exchange.readbundle(self.ui, cg, None)
21071
19b9f23a8c6f bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21070
diff changeset
   128
            ret = exchange.unbundle(self._repo, cg, heads, 'push', url)
19b9f23a8c6f bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21070
diff changeset
   129
            if util.safehasattr(ret, 'getchunks'):
19b9f23a8c6f bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21070
diff changeset
   130
                # This is a bundle20 object, turn it into an unbundler.
19b9f23a8c6f bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21070
diff changeset
   131
                # This little dance should be dropped eventually when the API
19b9f23a8c6f bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21070
diff changeset
   132
                # is finally improved.
19b9f23a8c6f bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21070
diff changeset
   133
                stream = util.chunkbuffer(ret.getchunks())
19b9f23a8c6f bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21070
diff changeset
   134
                ret = bundle2.unbundle20(self.ui, stream)
19b9f23a8c6f bundle2: return a bundle20 object from exchanges.unbundle
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21070
diff changeset
   135
            return ret
20969
7a679918ee2b localrepo: add unbundle support
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20963
diff changeset
   136
        except exchange.PushRaced, exc:
7a679918ee2b localrepo: add unbundle support
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20963
diff changeset
   137
            raise error.ResponseError(_('push failed:'), exc.message)
7a679918ee2b localrepo: add unbundle support
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20963
diff changeset
   138
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   139
    def lock(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   140
        return self._repo.lock()
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   141
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   142
    def addchangegroup(self, cg, source, url):
20933
d3775db748a0 localrepo: move the addchangegroup method in changegroup module
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20932
diff changeset
   143
        return changegroup.addchangegroup(self._repo, cg, source, url)
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   144
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   145
    def pushkey(self, namespace, key, old, new):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   146
        return self._repo.pushkey(namespace, key, old, new)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   147
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   148
    def listkeys(self, namespace):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   149
        return self._repo.listkeys(namespace)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   150
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   151
    def debugwireargs(self, one, two, three=None, four=None, five=None):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   152
        '''used to test argument passing over the wire'''
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   153
        return "%s %s %s %s %s" % (one, two, three, four, five)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   154
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   155
class locallegacypeer(localpeer):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   156
    '''peer extension which implements legacy methods too; used for tests with
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   157
    restricted capabilities'''
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   158
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   159
    def __init__(self, repo):
20776
d00c731f4637 localrepo: rename capability set to lower case.
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20773
diff changeset
   160
        localpeer.__init__(self, repo, caps=legacycaps)
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   161
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   162
    def branches(self, nodes):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   163
        return self._repo.branches(nodes)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   164
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   165
    def between(self, pairs):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   166
        return self._repo.between(pairs)
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   167
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   168
    def changegroup(self, basenodes, source):
20931
de60ca3a390e localrepo: move the changegroup method in changegroup module
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20930
diff changeset
   169
        return changegroup.changegroup(self._repo, basenodes, source)
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   170
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   171
    def changegroupsubset(self, bases, heads, source):
20927
24a443948627 localrepo: move the changegroupsubset method in changegroup module
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20926
diff changeset
   172
        return changegroup.changegroupsubset(self._repo, bases, heads, source)
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   173
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   174
class localrepository(object):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   175
14270
d6907a5674a2 revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14232
diff changeset
   176
    supportedformats = set(('revlogv1', 'generaldelta'))
19778
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   177
    _basesupported = supportedformats | set(('store', 'fncache', 'shared',
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   178
                                             'dotencode'))
17137
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   179
    openerreqs = set(('revlogv1', 'generaldelta'))
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   180
    requirements = ['revlogv1']
18186
d336f53cb2e3 clfilter: ensure unfiltered repo have a filtername attribute too
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18162
diff changeset
   181
    filtername = None
17137
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   182
21144
7a20fe8dc080 bundle2: use HG2X in the header
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21141
diff changeset
   183
    bundle2caps = {'HG2X': ()}
21140
4aeb8da68090 bundle2: add bundle2caps dict on localrepo object
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21106
diff changeset
   184
19928
d1ac3790e10a localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19884
diff changeset
   185
    # a list of (ui, featureset) functions.
d1ac3790e10a localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19884
diff changeset
   186
    # only functions defined in module of enabled extensions are invoked
19778
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   187
    featuresetupfuncs = set()
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   188
17137
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   189
    def _baserequirements(self, create):
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   190
        return self.requirements[:]
2439
e8c4f3d3df8c extend network protocol to stop clients from locking servers
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2424
diff changeset
   191
14363
82f3b0f3f0a5 localrepo, sshrepo: use Boolean create argument in __init__
Martin Geisler <mg@lazybytes.net>
parents: 14333
diff changeset
   192
    def __init__(self, baseui, path=None, create=False):
18945
e75b72fffdfe vfs: split "expand" into "realpath"/"expandpath" to apply each separately
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18811
diff changeset
   193
        self.wvfs = scmutil.vfs(path, expandpath=True, realpath=True)
17650
bf2eb3a126d2 localrepo: use "vfs" constructor instead of "opener" one
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17550
diff changeset
   194
        self.wopener = self.wvfs
17157
87e8440964a0 localrepo: use path expansion API via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17156
diff changeset
   195
        self.root = self.wvfs.base
17158
60338880d265 localrepo: use "self.wvfs.join()" instead of "os.path.join()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17157
diff changeset
   196
        self.path = self.wvfs.join(".hg")
3850
a4457828ca1a move code around
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3803
diff changeset
   197
        self.origroot = path
20033
f962870712da pathutil: tease out a new library to break an import cycle from canonpath use
Augie Fackler <raf@durin42.com>
parents: 20027
diff changeset
   198
        self.auditor = pathutil.pathauditor(self.root, self._checknested)
17650
bf2eb3a126d2 localrepo: use "vfs" constructor instead of "opener" one
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17550
diff changeset
   199
        self.vfs = scmutil.vfs(self.path)
bf2eb3a126d2 localrepo: use "vfs" constructor instead of "opener" one
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17550
diff changeset
   200
        self.opener = self.vfs
8797
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   201
        self.baseui = baseui
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   202
        self.ui = baseui.copy()
20082
b04cc8651a63 localrepo: prevent to copy repo local config, copy baseui instead
Simon Heimberg <simohe@besonet.ch>
parents: 20033
diff changeset
   203
        self.ui.copy = baseui.copy # prevent copying repo configuration
15922
23921c17299a phases: mechanism to allow extension to alter initial computation of phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15892
diff changeset
   204
        # A list of callback to shape the phase if no data were found.
23921c17299a phases: mechanism to allow extension to alter initial computation of phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15892
diff changeset
   205
        # Callback are in the form: func(repo, roots) --> processed root.
23921c17299a phases: mechanism to allow extension to alter initial computation of phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15892
diff changeset
   206
        # This list it to be filled by extension during repo setup
23921c17299a phases: mechanism to allow extension to alter initial computation of phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15892
diff changeset
   207
        self._phasedefaults = []
8797
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   208
        try:
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   209
            self.ui.readconfig(self.join("hgrc"), self.root)
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   210
            extensions.loadall(self.ui)
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   211
        except IOError:
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   212
            pass
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   213
19778
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   214
        if self.featuresetupfuncs:
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   215
            self.supported = set(self._basesupported) # use private copy
19928
d1ac3790e10a localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19884
diff changeset
   216
            extmods = set(m.__name__ for n, m
d1ac3790e10a localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19884
diff changeset
   217
                          in extensions.extensions(self.ui))
19778
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   218
            for setupfunc in self.featuresetupfuncs:
19928
d1ac3790e10a localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19884
diff changeset
   219
                if setupfunc.__module__ in extmods:
d1ac3790e10a localrepo: invoke only feature setup functions for enabled extensions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19884
diff changeset
   220
                    setupfunc(self.ui, self.supported)
19778
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   221
        else:
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   222
            self.supported = self._basesupported
55ef79031009 localrepo: make supported features manageable in each repositories individually
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 19650
diff changeset
   223
17161
be016e96117a localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17160
diff changeset
   224
        if not self.vfs.isdir():
3035
4d0e0f149581 localrepo: move the repo creation code, fail if the repo exists
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3019
diff changeset
   225
            if create:
17161
be016e96117a localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17160
diff changeset
   226
                if not self.wvfs.exists():
be016e96117a localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17160
diff changeset
   227
                    self.wvfs.makedirs()
be016e96117a localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17160
diff changeset
   228
                self.vfs.makedir(notindexed=True)
17137
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   229
                requirements = self._baserequirements(create)
8797
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   230
                if self.ui.configbool('format', 'usestore', True):
17161
be016e96117a localrepo: use file API via vfs while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17160
diff changeset
   231
                    self.vfs.mkdir("store")
4166
c0271aba6abe small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4163
diff changeset
   232
                    requirements.append("store")
8797
9ed150d2fbd5 repo: set up ui and extensions earlier
Matt Mackall <mpm@selenic.com>
parents: 8796
diff changeset
   233
                    if self.ui.configbool('format', 'usefncache', True):
7234
ae70fe6143fc add format.usefncache config option (default is true)
Adrian Buehlmann <adrian@cadifra.com>
parents: 7233
diff changeset
   234
                        requirements.append("fncache")
12687
34d8247a4595 store: encode first period or space in filenames (issue1713)
Adrian Buehlmann <adrian@cadifra.com>
parents: 12622
diff changeset
   235
                        if self.ui.configbool('format', 'dotencode', True):
34d8247a4595 store: encode first period or space in filenames (issue1713)
Adrian Buehlmann <adrian@cadifra.com>
parents: 12622
diff changeset
   236
                            requirements.append('dotencode')
4166
c0271aba6abe small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4163
diff changeset
   237
                    # create an invalid changelog
17160
22b9b1d2f5d4 localrepo: use "vfs" intead of "opener" while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17159
diff changeset
   238
                    self.vfs.append(
14168
135e244776f0 prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 14162
diff changeset
   239
                        "00changelog.i",
4166
c0271aba6abe small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4163
diff changeset
   240
                        '\0\0\0\2' # represents revlogv2
c0271aba6abe small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4163
diff changeset
   241
                        ' dummy changelog to prevent using the old repo layout'
c0271aba6abe small fixes for the parent patch
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4163
diff changeset
   242
                    )
14270
d6907a5674a2 revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14232
diff changeset
   243
                if self.ui.configbool('format', 'generaldelta', False):
d6907a5674a2 revlog: support writing generaldelta revlogs
Sune Foldager <cryo@cyanite.org>
parents: 14232
diff changeset
   244
                    requirements.append("generaldelta")
14905
207935cda6dc localrepo: make requirements attribute of newly-created repos contain a set
Andrew Pritchard <andrewp@fogcreek.com>
parents: 14904
diff changeset
   245
                requirements = set(requirements)
3035
4d0e0f149581 localrepo: move the repo creation code, fail if the repo exists
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3019
diff changeset
   246
            else:
7637
1d54e2f6c0b7 error: move repo errors
Matt Mackall <mpm@selenic.com>
parents: 7633
diff changeset
   247
                raise error.RepoError(_("repository %s not found") % path)
3035
4d0e0f149581 localrepo: move the repo creation code, fail if the repo exists
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3019
diff changeset
   248
        elif create:
7637
1d54e2f6c0b7 error: move repo errors
Matt Mackall <mpm@selenic.com>
parents: 7633
diff changeset
   249
            raise error.RepoError(_("repository %s already exists") % path)
3851
8f18e31c4441 add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3850
diff changeset
   250
        else:
8f18e31c4441 add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3850
diff changeset
   251
            try:
17160
22b9b1d2f5d4 localrepo: use "vfs" intead of "opener" while ensuring repository directory
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17159
diff changeset
   252
                requirements = scmutil.readrequires(self.vfs, self.supported)
3851
8f18e31c4441 add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3850
diff changeset
   253
            except IOError, inst:
8f18e31c4441 add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3850
diff changeset
   254
                if inst.errno != errno.ENOENT:
8f18e31c4441 add "requires" file to the repo, specifying the requirements
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3850
diff changeset
   255
                    raise
14482
58b36e9ea783 introduce new function scmutil.readrequires
Adrian Buehlmann <adrian@cadifra.com>
parents: 14434
diff changeset
   256
                requirements = set()
405
99470ae6b424 Check if repository exists
mpm@selenic.com
parents: 402
diff changeset
   257
8799
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   258
        self.sharedpath = self.path
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   259
        try:
18946
3d4f41eaae67 localrepo: use vfs instead of "os.path.*" in sharedpath checking
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18945
diff changeset
   260
            vfs = scmutil.vfs(self.vfs.read("sharedpath").rstrip('\n'),
3d4f41eaae67 localrepo: use vfs instead of "os.path.*" in sharedpath checking
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18945
diff changeset
   261
                              realpath=True)
3d4f41eaae67 localrepo: use vfs instead of "os.path.*" in sharedpath checking
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18945
diff changeset
   262
            s = vfs.base
3d4f41eaae67 localrepo: use vfs instead of "os.path.*" in sharedpath checking
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18945
diff changeset
   263
            if not vfs.exists():
8799
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   264
                raise error.RepoError(
8908
105343f9f744 Fix warning: Seen unexpected token "%"
Dongsheng Song <dongsheng.song@gmail.com>
parents: 8813
diff changeset
   265
                    _('.hg/sharedpath points to nonexistent directory %s') % s)
8799
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   266
            self.sharedpath = s
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   267
        except IOError, inst:
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   268
            if inst.errno != errno.ENOENT:
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   269
                raise
87d1fd40f57e repo: add internal support for sharing store directories
Matt Mackall <mpm@selenic.com>
parents: 8797
diff changeset
   270
17654
1dc37491e9fb localrepo: use "vfs" constructor/field for initialization around "store"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17650
diff changeset
   271
        self.store = store.store(requirements, self.sharedpath, scmutil.vfs)
6840
80e51429cb9a introduce store classes
Adrian Buehlmann <adrian@cadifra.com>
parents: 6839
diff changeset
   272
        self.spath = self.store.path
17654
1dc37491e9fb localrepo: use "vfs" constructor/field for initialization around "store"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17650
diff changeset
   273
        self.svfs = self.store.vfs
1dc37491e9fb localrepo: use "vfs" constructor/field for initialization around "store"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17650
diff changeset
   274
        self.sopener = self.svfs
6840
80e51429cb9a introduce store classes
Adrian Buehlmann <adrian@cadifra.com>
parents: 6839
diff changeset
   275
        self.sjoin = self.store.join
17654
1dc37491e9fb localrepo: use "vfs" constructor/field for initialization around "store"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17650
diff changeset
   276
        self.vfs.createmode = self.store.createmode
12295
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   277
        self._applyrequirements(requirements)
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   278
        if create:
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   279
            self._writerequirements()
3850
a4457828ca1a move code around
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3803
diff changeset
   280
9146
5614a628d173 localrepo: rename in-memory tag cache instance attributes (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9145
diff changeset
   281
18189
b9026ba002f6 branchmap: enable caching for filtered version too
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18186
diff changeset
   282
        self._branchcaches = {}
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   283
        self.filterpats = {}
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   284
        self._datafilters = {}
4916
5c5d23d93447 Use a weakref for recursive transactions
Matt Mackall <mpm@selenic.com>
parents: 4915
diff changeset
   285
        self._transref = self._lockref = self._wlockref = None
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   286
14929
4bf9493e7b07 localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents: 14905
diff changeset
   287
        # A cache for various files under .hg/ that tracks file changes,
4bf9493e7b07 localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents: 14905
diff changeset
   288
        # (used by the filecache decorator)
4bf9493e7b07 localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents: 14905
diff changeset
   289
        #
4bf9493e7b07 localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents: 14905
diff changeset
   290
        # Maps a property name to its util.filecacheentry
4bf9493e7b07 localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents: 14905
diff changeset
   291
        self._filecache = {}
4bf9493e7b07 localrepo: add a cache with stat info for files under .hg/
Idan Kamara <idankk86@gmail.com>
parents: 14905
diff changeset
   292
18101
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   293
        # hold sets of revision to be filtered
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   294
        # should be cleared when something might have changed the filter value:
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   295
        # - new changesets,
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   296
        # - phase change,
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   297
        # - new obsolescence marker,
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   298
        # - working directory parent change,
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   299
        # - bookmark changes
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   300
        self.filteredrevcache = {}
a464deecc9dd clfilter: add a cache on repo for set of revision to filter for a given set.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18100
diff changeset
   301
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   302
    def close(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   303
        pass
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   304
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   305
    def _restrictcapabilities(self, caps):
20955
12f161f08d74 bundle2: allow pulling changegroups using bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20954
diff changeset
   306
        # bundle2 is not ready for prime time, drop it unless explicitly
12f161f08d74 bundle2: allow pulling changegroups using bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20954
diff changeset
   307
        # required by the tests (or some brave tester)
21141
d8dd19e09ed4 bundle2: advertise bundle2 caps in server capabilities
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21140
diff changeset
   308
        if self.ui.configbool('server', 'bundle2', False):
20955
12f161f08d74 bundle2: allow pulling changegroups using bundle2
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20954
diff changeset
   309
            caps = set(caps)
21141
d8dd19e09ed4 bundle2: advertise bundle2 caps in server capabilities
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21140
diff changeset
   310
            capsblob = bundle2.encodecaps(self.bundle2caps)
d8dd19e09ed4 bundle2: advertise bundle2 caps in server capabilities
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 21140
diff changeset
   311
            caps.add('bundle2=' + urllib.quote(capsblob))
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   312
        return caps
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   313
12295
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   314
    def _applyrequirements(self, requirements):
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   315
        self.requirements = requirements
14333
31a5973fcf96 revlog: get rid of defversion
Sune Foldager <cryo@cyanite.org>
parents: 14274
diff changeset
   316
        self.sopener.options = dict((r, 1) for r in requirements
17137
b090601a80d1 localrepo: make requirements and openerreqs mutable by subclasses
Bryan O'Sullivan <bryano@fb.com>
parents: 17075
diff changeset
   317
                                           if r in self.openerreqs)
20180
969148b49fc6 revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents: 20176
diff changeset
   318
        chunkcachesize = self.ui.configint('format', 'chunkcachesize')
969148b49fc6 revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents: 20176
diff changeset
   319
        if chunkcachesize is not None:
969148b49fc6 revlog: allow tuning of the chunk cache size (via format.chunkcachesize)
Brodie Rao <brodie@sf.io>
parents: 20176
diff changeset
   320
            self.sopener.options['chunkcachesize'] = chunkcachesize
12295
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   321
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   322
    def _writerequirements(self):
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   323
        reqfile = self.opener("requires", "w")
18356
752f77ef7202 localrepo: store requirements sorted
Mads Kiilerich <mads@kiilerich.com>
parents: 18318
diff changeset
   324
        for r in sorted(self.requirements):
12295
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   325
            reqfile.write("%s\n" % r)
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   326
        reqfile.close()
3388ab21d768 localrepo: factor out requirement application and write
Sune Foldager <cryo@cyanite.org>
parents: 12176
diff changeset
   327
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   328
    def _checknested(self, path):
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   329
        """Determine if path is a legal nested repository."""
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   330
        if not path.startswith(self.root):
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   331
            return False
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   332
        subpath = path[len(self.root) + 1:]
15722
417127af3996 windows: use normalized path to check repository nesting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15604
diff changeset
   333
        normsubpath = util.pconvert(subpath)
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   334
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   335
        # XXX: Checking against the current working copy is wrong in
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   336
        # the sense that it can reject things like
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   337
        #
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   338
        #   $ hg cat -r 10 sub/x.txt
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   339
        #
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   340
        # if sub/ is no longer a subrepository in the working copy
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   341
        # parent revision.
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   342
        #
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   343
        # However, it can of course also allow things that would have
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   344
        # been rejected before, such as the above cat command if sub/
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   345
        # is a subrepository now, but was a normal directory before.
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   346
        # The old path auditor would have rejected by mistake since it
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   347
        # panics when it sees sub/.hg/.
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   348
        #
12174
7bccd04292a2 localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents: 12166
diff changeset
   349
        # All in all, checking against the working copy seems sensible
7bccd04292a2 localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents: 12166
diff changeset
   350
        # since we want to prevent access to nested repositories on
7bccd04292a2 localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents: 12166
diff changeset
   351
        # the filesystem *now*.
7bccd04292a2 localrepo: check nested repos against working directory
Martin Geisler <mg@lazybytes.net>
parents: 12166
diff changeset
   352
        ctx = self[None]
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   353
        parts = util.splitpath(subpath)
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   354
        while parts:
15722
417127af3996 windows: use normalized path to check repository nesting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15604
diff changeset
   355
            prefix = '/'.join(parts)
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   356
            if prefix in ctx.substate:
15722
417127af3996 windows: use normalized path to check repository nesting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15604
diff changeset
   357
                if prefix == normsubpath:
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   358
                    return True
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   359
                else:
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   360
                    sub = ctx.sub(prefix)
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   361
                    return sub.checknested(subpath[len(prefix) + 1:])
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   362
            else:
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   363
                parts.pop()
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   364
        return False
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   365
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   366
    def peer(self):
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   367
        return localpeer(self) # not cached to avoid reference cycle
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   368
17993
1a6f8820eb71 clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17922
diff changeset
   369
    def unfiltered(self):
1a6f8820eb71 clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17922
diff changeset
   370
        """Return unfiltered version of the repository
1a6f8820eb71 clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17922
diff changeset
   371
18644
3e92772d5383 spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents: 18520
diff changeset
   372
        Intended to be overwritten by filtered repo."""
17993
1a6f8820eb71 clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17922
diff changeset
   373
        return self
1a6f8820eb71 clfilter: introduce an "unfiltered" method on localrepo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17922
diff changeset
   374
18100
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   375
    def filtered(self, name):
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   376
        """Return a filtered version of a repository"""
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   377
        # build a new class with the mixin and the current class
18644
3e92772d5383 spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents: 18520
diff changeset
   378
        # (possibly subclass of the repo)
18100
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   379
        class proxycls(repoview.repoview, self.unfiltered().__class__):
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   380
            pass
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   381
        return proxycls(self, name)
3a6ddacb7198 clfilter: add actual repo filtering mechanism
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18092
diff changeset
   382
18014
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
   383
    @repofilecache('bookmarks')
13355
cce2e7b77e36 bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents: 13341
diff changeset
   384
    def _bookmarks(self):
17922
7f5dab94e48c bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents: 17857
diff changeset
   385
        return bookmarks.bmstore(self)
13355
cce2e7b77e36 bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents: 13341
diff changeset
   386
18014
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
   387
    @repofilecache('bookmarks.current')
13355
cce2e7b77e36 bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents: 13341
diff changeset
   388
    def _bookmarkcurrent(self):
cce2e7b77e36 bookmarks: move property methods into localrepo
Matt Mackall <mpm@selenic.com>
parents: 13341
diff changeset
   389
        return bookmarks.readcurrent(self)
12162
af8c4929931c localrepo: add auditor attribute which knows about subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12127
diff changeset
   390
16707
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   391
    def bookmarkheads(self, bookmark):
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   392
        name = bookmark.split('@', 1)[0]
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   393
        heads = []
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   394
        for mark, n in self._bookmarks.iteritems():
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   395
            if mark.split('@', 1)[0] == name:
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   396
                heads.append(n)
f8dee1a8f844 localrepo: introduce bookmarkheads
David Soria Parra <dsp@php.net>
parents: 16706
diff changeset
   397
        return heads
15418
cf729af26963 phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15403
diff changeset
   398
16198
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
   399
    @storecache('phaseroots')
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16646
diff changeset
   400
    def _phasecache(self):
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16646
diff changeset
   401
        return phases.phasecache(self, self._phasedefaults)
15420
e80d0d3198f0 phases: add a cache allowing to know in which phase a changeset is
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15418
diff changeset
   402
17070
ad0d6c2b3279 obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents: 17013
diff changeset
   403
    @storecache('obsstore')
ad0d6c2b3279 obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents: 17013
diff changeset
   404
    def obsstore(self):
17124
f1b7683f3f95 obsolete: move obsolete markers read/write logic to obsstore object
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17075
diff changeset
   405
        store = obsolete.obsstore(self.sopener)
17297
6955d69a52a4 obsolete: warns if markers exist in a repo where the feature is not enabled
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17295
diff changeset
   406
        if store and not obsolete._enabled:
17306
7d2967de2c04 obsolete: fix typos in comments introduced by 6955d69a52a4
Thomas Arendsen Hein <thomas@intevation.de>
parents: 17299
diff changeset
   407
            # message is rare enough to not be translated
17297
6955d69a52a4 obsolete: warns if markers exist in a repo where the feature is not enabled
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17295
diff changeset
   408
            msg = 'obsolete feature not enabled but %i markers found!\n'
6955d69a52a4 obsolete: warns if markers exist in a repo where the feature is not enabled
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17295
diff changeset
   409
            self.ui.warn(msg % len(list(store)))
17070
ad0d6c2b3279 obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents: 17013
diff changeset
   410
        return store
ad0d6c2b3279 obsolete: introduction of obsolete markers
Pierre-Yves.David@ens-lyon.org
parents: 17013
diff changeset
   411
16198
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
   412
    @storecache('00changelog.i')
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   413
    def changelog(self):
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   414
        c = changelog.changelog(self.sopener)
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   415
        if 'HG_PENDING' in os.environ:
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   416
            p = os.environ['HG_PENDING']
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   417
            if p.startswith(self.root):
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   418
                c.readpending('00changelog.i.a')
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   419
        return c
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   420
16198
fa8488565afd filecache: refactor path join logic to a function
Idan Kamara <idankk86@gmail.com>
parents: 16144
diff changeset
   421
    @storecache('00manifest.i')
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   422
    def manifest(self):
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   423
        return manifest.manifest(self.sopener)
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   424
18014
a39fe76c4c65 clfilter: ensure that filecache on localrepo is unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18013
diff changeset
   425
    @repofilecache('dirstate')
8260
54a4b520bd7d localrepo: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8244
diff changeset
   426
    def dirstate(self):
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   427
        warned = [0]
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   428
        def validate(node):
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   429
            try:
14064
e4bfb9c337f3 remove unused imports and variables
Alexander Solovyov <alexander@solovyov.net>
parents: 14056
diff changeset
   430
                self.changelog.rev(node)
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   431
                return node
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   432
            except error.LookupError:
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   433
                if not warned[0]:
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   434
                    warned[0] = True
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   435
                    self.ui.warn(_("warning: ignoring unknown"
13037
9beac11b8c56 localrepo: move string formatting out of gettext call
Martin Geisler <mg@aragost.com>
parents: 13032
diff changeset
   436
                                   " working parent %s!\n") % short(node))
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   437
                return nullid
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   438
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 13001
diff changeset
   439
        return dirstate.dirstate(self.opener, self.ui, self.root, validate)
2155
ff255b41b4aa support hooks written in python.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2150
diff changeset
   440
6747
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   441
    def __getitem__(self, changeid):
8527
f9a80054dd3c use 'x is None' instead of 'x == None'
Martin Geisler <mg@lazybytes.net>
parents: 8515
diff changeset
   442
        if changeid is None:
6747
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   443
            return context.workingctx(self)
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   444
        return context.changectx(self, changeid)
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   445
9924
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   446
    def __contains__(self, changeid):
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   447
        try:
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   448
            return bool(self.lookup(changeid))
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   449
        except error.RepoLookupError:
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   450
            return False
ea3acaae25bb localrepo: support 'rev in repo' syntax
Alexander Solovyov <piranha@piranha.org.ua>
parents: 9820
diff changeset
   451
6750
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   452
    def __nonzero__(self):
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   453
        return True
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   454
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   455
    def __len__(self):
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   456
        return len(self.changelog)
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   457
fb42030d79d6 add __len__ and __iter__ methods to repo and revlog
Matt Mackall <mpm@selenic.com>
parents: 6747
diff changeset
   458
    def __iter__(self):
17675
8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17670
diff changeset
   459
        return iter(self.changelog)
2155
ff255b41b4aa support hooks written in python.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2150
diff changeset
   460
15403
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   461
    def revs(self, expr, *args):
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   462
        '''Return a list of revisions matching the given revset'''
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   463
        expr = revset.formatspec(expr, *args)
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   464
        m = revset.match(None, expr)
20646
a4d587c6e3dd localrepo: changed revs to use spanset instead of baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20627
diff changeset
   465
        return m(self, revset.spanset(self))
15403
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   466
14902
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
   467
    def set(self, expr, *args):
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
   468
        '''
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
   469
        Yield a context for each matching revision, after doing arg
14904
ff2d907a5af8 localrepo: fix comment on set
Matt Mackall <mpm@selenic.com>
parents: 14902
diff changeset
   470
        replacement via revset.formatspec
14902
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
   471
        '''
15403
e27561eb4a76 localrepo: add revs helper method
Matt Mackall <mpm@selenic.com>
parents: 15381
diff changeset
   472
        for r in self.revs(expr, *args):
14902
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
   473
            yield self[r]
96a72cbc6c29 localrepo: add set method to iterate over a given revset
Matt Mackall <mpm@selenic.com>
parents: 14870
diff changeset
   474
2673
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2661
diff changeset
   475
    def url(self):
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2661
diff changeset
   476
        return 'file:' + self.root
109a22f5434a hooks: add url to changegroup, incoming, prechangegroup, pretxnchangegroup hooks
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2661
diff changeset
   477
1718
c1996b84d4f5 make hook code nicer.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1717
diff changeset
   478
    def hook(self, name, throw=False, **args):
4622
fff50306e6dd hooks: separate hook code into a separate module
Matt Mackall <mpm@selenic.com>
parents: 4619
diff changeset
   479
        return hook.hook(self.ui, self, name, throw, **args)
487
2ad41189bee5 Add initial hook support
mpm@selenic.com
parents: 484
diff changeset
   480
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
   481
    @unfilteredmethod
8402
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   482
    def _tag(self, names, node, message, local, user, date, extra={}):
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   483
        if isinstance(names, str):
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   484
            names = (names,)
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   485
11063
eb23c876c111 tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11047
diff changeset
   486
        branches = self.branchmap()
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   487
        for name in names:
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   488
            self.hook('pretag', throw=True, node=hex(node), tag=name,
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   489
                      local=local)
11063
eb23c876c111 tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11047
diff changeset
   490
            if name in branches:
eb23c876c111 tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11047
diff changeset
   491
                self.ui.warn(_("warning: tag %s conflicts with existing"
eb23c876c111 tag: warn users about tag/branch possible name conflicts
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11047
diff changeset
   492
                " branch name\n") % name)
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   493
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   494
        def writetags(fp, names, munge, prevtags):
5985
850494d62674 localrepo._tag: add a seek before writing the new tag
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5882
diff changeset
   495
            fp.seek(0, 2)
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   496
            if prevtags and prevtags[-1] != '\n':
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   497
                fp.write('\n')
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   498
            for name in names:
6671
938eddd76237 tag: record tag we're superseding, if any (issue 1102)
Matt Mackall <mpm@selenic.com>
parents: 6647
diff changeset
   499
                m = munge and munge(name) or name
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
   500
                if (self._tagscache.tagtypes and
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
   501
                    name in self._tagscache.tagtypes):
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   502
                    old = self.tags().get(name, nullid)
6671
938eddd76237 tag: record tag we're superseding, if any (issue 1102)
Matt Mackall <mpm@selenic.com>
parents: 6647
diff changeset
   503
                    fp.write('%s %s\n' % (hex(old), m))
938eddd76237 tag: record tag we're superseding, if any (issue 1102)
Matt Mackall <mpm@selenic.com>
parents: 6647
diff changeset
   504
                fp.write('%s %s\n' % (hex(node), m))
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   505
            fp.close()
5081
ea7b982b6c08 Remove trailing spaces
Thomas Arendsen Hein <thomas@intevation.de>
parents: 4932
diff changeset
   506
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   507
        prevtags = ''
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   508
        if local:
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   509
            try:
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   510
                fp = self.opener('localtags', 'r+')
7875
553aa0cbeab6 cleanup: drop unused assignments
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 7848
diff changeset
   511
            except IOError:
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   512
                fp = self.opener('localtags', 'a')
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   513
            else:
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   514
                prevtags = fp.read()
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   515
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   516
            # local tags are stored in the current charset
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   517
            writetags(fp, names, None, prevtags)
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   518
            for name in names:
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   519
                self.hook('tag', node=hex(node), tag=name, local=local)
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   520
            return
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   521
8402
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   522
        try:
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   523
            fp = self.wfile('.hgtags', 'rb+')
14646
001788ef4bbb localrepo: don't attempt to open .hgtags twice if the error isn't ENOENT
Idan Kamara <idankk86@gmail.com>
parents: 14603
diff changeset
   524
        except IOError, e:
001788ef4bbb localrepo: don't attempt to open .hgtags twice if the error isn't ENOENT
Idan Kamara <idankk86@gmail.com>
parents: 14603
diff changeset
   525
            if e.errno != errno.ENOENT:
001788ef4bbb localrepo: don't attempt to open .hgtags twice if the error isn't ENOENT
Idan Kamara <idankk86@gmail.com>
parents: 14603
diff changeset
   526
                raise
8402
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   527
            fp = self.wfile('.hgtags', 'ab')
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   528
        else:
8402
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   529
            prevtags = fp.read()
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   530
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   531
        # committed tags are stored in UTF-8
7948
de377b1a9a84 move encoding bits from util to encoding
Matt Mackall <mpm@selenic.com>
parents: 7930
diff changeset
   532
        writetags(fp, names, encoding.fromlocal, prevtags)
4932
f0c25ed40ec6 tag: handle .hgtags and .hg/localtags with missing final newline (issue 601)
Bryan O'Sullivan <bos@serpentine.com>
parents: 4929
diff changeset
   533
13400
14f3795a5ed7 explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 13391
diff changeset
   534
        fp.close()
14f3795a5ed7 explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 13391
diff changeset
   535
15929
4091660dc130 tag: invalidate tag cache immediately after adding new tag (issue3210)
Mads Kiilerich <mads@kiilerich.com>
parents: 15922
diff changeset
   536
        self.invalidatecaches()
4091660dc130 tag: invalidate tag cache immediately after adding new tag (issue3210)
Mads Kiilerich <mads@kiilerich.com>
parents: 15922
diff changeset
   537
8402
0ad521500424 tag: drop unused use_dirstate and parent from _tag()
Matt Mackall <mpm@selenic.com>
parents: 8401
diff changeset
   538
        if '.hgtags' not in self.dirstate:
11303
a1aad8333864 move working dir/dirstate methods from localrepo to workingctx
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 11301
diff changeset
   539
            self[None].add(['.hgtags'])
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   540
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
   541
        m = matchmod.exact(self.root, '', ['.hgtags'])
8706
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
   542
        tagnode = self.commit(message, user, date, extra=extra, match=m)
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   543
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   544
        for name in names:
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   545
            self.hook('tag', node=hex(node), tag=name, local=local)
4118
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   546
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   547
        return tagnode
35b39097c3e6 Break core of repo.tag into dirstate/hook-free repo._tag for convert-repo
Brendan Cully <brendan@kublai.com>
parents: 4070
diff changeset
   548
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   549
    def tag(self, names, node, message, local, user, date):
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   550
        '''tag a revision with one or more symbolic names.
2601
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   551
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   552
        names is a list of strings or, when adding a single tag, names may be a
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   553
        string.
6334
7016f7fb8fe3 tab/space cleanup
Thomas Arendsen Hein <thomas@intevation.de>
parents: 6321
diff changeset
   554
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   555
        if local is True, the tags are stored in a per-repository file.
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   556
        otherwise, they are stored in the .hgtags file, and a new
2601
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   557
        changeset is committed with the change.
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   558
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   559
        keyword arguments:
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   560
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   561
        local: whether to store tags in non-version-controlled file
2601
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   562
        (default False)
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   563
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   564
        message: commit message to use if committing
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   565
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   566
        user: name of user to use if committing
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   567
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   568
        date: date tuple to use if committing'''
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   569
13133
c1492615cdee tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents: 13000
diff changeset
   570
        if not local:
c1492615cdee tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents: 13000
diff changeset
   571
            for x in self.status()[:5]:
c1492615cdee tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents: 13000
diff changeset
   572
                if '.hgtags' in x:
c1492615cdee tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents: 13000
diff changeset
   573
                    raise util.Abort(_('working copy of .hgtags is changed '
c1492615cdee tag: don't check .hgtags status if --local passed
Kevin Bullock <kbullock@ringworld.org>
parents: 13000
diff changeset
   574
                                       '(please commit .hgtags manually)'))
2601
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   575
7814
4421abf8c85d tag: force load of tag cache
Matt Mackall <mpm@selenic.com>
parents: 7803
diff changeset
   576
        self.tags() # instantiate the cache
6321
55ba3bc5b8fd tag: allow multiple tags to be added or removed
John Coomes <john.coomes@sun.com>
parents: 6312
diff changeset
   577
        self._tag(names, node, message, local, user, date)
2601
00fc88b0b256 move most of tag code to localrepository class.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2581
diff changeset
   578
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   579
    @filteredpropertycache
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   580
    def _tagscache(self):
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
   581
        '''Returns a tagscache object that contains various tags related
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
   582
        caches.'''
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   583
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   584
        # This simplifies its cache management by having one decorated
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   585
        # function (this one) and the rest simply fetch things from it.
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   586
        class tagscache(object):
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   587
            def __init__(self):
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   588
                # These two define the set of tags for this repository. tags
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   589
                # maps tag name to node; tagtypes maps tag name to 'global' or
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   590
                # 'local'. (Global tags are defined by .hgtags across all
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   591
                # heads, and local tags are defined in .hg/localtags.)
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   592
                # They constitute the in-memory cache of tags.
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   593
                self.tags = self.tagtypes = None
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   594
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   595
                self.nodetagscache = self.tagslist = None
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   596
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   597
        cache = tagscache()
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   598
        cache.tags, cache.tagtypes = self._findtags()
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   599
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   600
        return cache
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   601
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   602
    def tags(self):
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   603
        '''return a mapping of tag to node'''
16371
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   604
        t = {}
17715
21c503480986 clfilter: do not use tags cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17714
diff changeset
   605
        if self.changelog.filteredrevs:
21c503480986 clfilter: do not use tags cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17714
diff changeset
   606
            tags, tt = self._findtags()
21c503480986 clfilter: do not use tags cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17714
diff changeset
   607
        else:
21c503480986 clfilter: do not use tags cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17714
diff changeset
   608
            tags = self._tagscache.tags
21c503480986 clfilter: do not use tags cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17714
diff changeset
   609
        for k, v in tags.iteritems():
16371
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   610
            try:
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   611
                # ignore tags to unknown nodes
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   612
                self.changelog.rev(v)
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   613
                t[k] = v
16679
2950d186a927 parsers: strictly check for 20-byte hashes where they're required
Bryan O'Sullivan <bryano@fb.com>
parents: 16551
diff changeset
   614
            except (error.LookupError, ValueError):
16371
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   615
                pass
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   616
        return t
4210
caff92047e87 Refactor tags code to prepare for improving the algorithm
Matt Mackall <mpm@selenic.com>
parents: 4178
diff changeset
   617
9145
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   618
    def _findtags(self):
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   619
        '''Do the hard work of finding tags.  Return a pair of dicts
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   620
        (tags, tagtypes) where tags maps tag name to node, and tagtypes
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   621
        maps tag name to a string like \'global\' or \'local\'.
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   622
        Subclasses or extensions are free to add their own tags, but
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   623
        should be aware that the returned dicts will be retained for the
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   624
        duration of the localrepo object.'''
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   625
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   626
        # XXX what tagtype should subclasses/extensions use?  Currently
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   627
        # mq and bookmarks add tags, but do not set the tagtype at all.
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   628
        # Should each extension invent its own tag type?  Should there
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   629
        # be one tagtype for all such "virtual" tags?  Or is the status
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   630
        # quo fine?
4210
caff92047e87 Refactor tags code to prepare for improving the algorithm
Matt Mackall <mpm@selenic.com>
parents: 4178
diff changeset
   631
9148
b7837f0ed9fe localrepo: factor updatetags() out of readtags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9147
diff changeset
   632
        alltags = {}                    # map tag name to (node, hist)
5657
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   633
        tagtypes = {}
659
3662e3d6b690 Whitespace cleanup
Matt Mackall <mpm@selenic.com>
parents: 658
diff changeset
   634
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
   635
        tagsmod.findglobaltags(self.ui, self, alltags, tagtypes)
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
   636
        tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)
5657
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   637
9152
4017291c4c48 tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents: 9151
diff changeset
   638
        # Build the return dicts.  Have to re-encode tag names because
4017291c4c48 tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents: 9151
diff changeset
   639
        # the tags module always uses UTF-8 (in order not to lose info
4017291c4c48 tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents: 9151
diff changeset
   640
        # writing to the cache), but the rest of Mercurial wants them in
4017291c4c48 tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents: 9151
diff changeset
   641
        # local encoding.
9145
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   642
        tags = {}
9147
234a230cc33b localrepo: improve readability of _findtags(), readtags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9146
diff changeset
   643
        for (name, (node, hist)) in alltags.iteritems():
234a230cc33b localrepo: improve readability of _findtags(), readtags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9146
diff changeset
   644
            if node != nullid:
16371
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   645
                tags[encoding.tolocal(name)] = node
9145
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   646
        tags['tip'] = self.changelog.tip()
9152
4017291c4c48 tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents: 9151
diff changeset
   647
        tagtypes = dict([(encoding.tolocal(name), value)
4017291c4c48 tags: support 'instant' tag retrieval (issue548)
Greg Ward <greg-hg@gerg.ca>
parents: 9151
diff changeset
   648
                         for (name, value) in tagtypes.iteritems()])
9145
6b03f93b8ff3 localrepo: factor _findtags() out of tags() (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9134
diff changeset
   649
        return (tags, tagtypes)
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   650
5657
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   651
    def tagtype(self, tagname):
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   652
        '''
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   653
        return the type of the given tag. result can be:
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   654
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   655
        'local'  : a local tag
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   656
        'global' : a global tag
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   657
        None     : tag does not exist
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   658
        '''
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   659
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   660
        return self._tagscache.tagtypes.get(tagname)
5657
47915bf68c44 Properly check tag's existence as a local/global tag when removing it.
Osku Salerma <osku@iki.fi>
parents: 5637
diff changeset
   661
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   662
    def tagslist(self):
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   663
        '''return a list of tags ordered by revision'''
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   664
        if not self._tagscache.tagslist:
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   665
            l = []
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   666
            for t, n in self.tags().iteritems():
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   667
                r = self.changelog.rev(n)
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   668
                l.append((r, t, n))
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   669
            self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)]
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   670
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   671
        return self._tagscache.tagslist
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   672
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   673
    def nodetags(self, node):
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   674
        '''return the tags associated with a node'''
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   675
        if not self._tagscache.nodetagscache:
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   676
            nodetagscache = {}
16371
4417eb761ba8 tags: defer tag validation until repo.tags() is called
Matt Mackall <mpm@selenic.com>
parents: 16361
diff changeset
   677
            for t, n in self._tagscache.tags.iteritems():
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   678
                nodetagscache.setdefault(n, []).append(t)
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   679
            for tags in nodetagscache.itervalues():
11047
c7dbd6c4877a tags: return tags in sorted order
Eric Eisner <ede@mit.edu>
parents: 10970
diff changeset
   680
                tags.sort()
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   681
            self._tagscache.nodetagscache = nodetagscache
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   682
        return self._tagscache.nodetagscache.get(node, [])
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   683
13384
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   684
    def nodebookmarks(self, node):
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   685
        marks = []
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   686
        for bookmark, n in self._bookmarks.iteritems():
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   687
            if n == node:
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   688
                marks.append(bookmark)
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   689
        return sorted(marks)
caa561759538 context: add method to return all bookmarks pointing to a node
David Soria Parra <dsp@php.net>
parents: 13365
diff changeset
   690
12066
d01e28657429 localrepo: introduce method for explicit branch cache update
Georg Brandl <georg@python.org>
parents: 12035
diff changeset
   691
    def branchmap(self):
20245
4edd179fefb8 help: branch names primarily denote the tipmost unclosed branch head
Mads Kiilerich <madski@unity3d.com>
parents: 20226
diff changeset
   692
        '''returns a dictionary {branch: [branchheads]} with branchheads
4edd179fefb8 help: branch names primarily denote the tipmost unclosed branch head
Mads Kiilerich <madski@unity3d.com>
parents: 20226
diff changeset
   693
        ordered by increasing revision number'''
18189
b9026ba002f6 branchmap: enable caching for filtered version too
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18186
diff changeset
   694
        branchmap.updatecache(self)
b9026ba002f6 branchmap: enable caching for filtered version too
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18186
diff changeset
   695
        return self._branchcaches[self.filtername]
17714
5210e5a556d9 clfilter: do not use branchmap cache if there are filtered changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17675
diff changeset
   696
16719
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   697
    def branchtip(self, branch):
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   698
        '''return the tip node for a given branch'''
20187
4d6d5ef88538 localrepo: refactor repo.branchtip() to use repo.branchmap().branchtip()
Brodie Rao <brodie@sf.io>
parents: 20184
diff changeset
   699
        try:
4d6d5ef88538 localrepo: refactor repo.branchtip() to use repo.branchmap().branchtip()
Brodie Rao <brodie@sf.io>
parents: 20184
diff changeset
   700
            return self.branchmap().branchtip(branch)
4d6d5ef88538 localrepo: refactor repo.branchtip() to use repo.branchmap().branchtip()
Brodie Rao <brodie@sf.io>
parents: 20184
diff changeset
   701
        except KeyError:
16719
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   702
            raise error.RepoLookupError(_("unknown branch '%s'") % branch)
e7bf09acd410 localrepo: add branchtip() method for faster single-branch lookups
Brodie Rao <brodie@sf.io>
parents: 16716
diff changeset
   703
343
d7df759d0e97 rework all code using tags
mpm@selenic.com
parents: 337
diff changeset
   704
    def lookup(self, key):
16378
c463f46fe050 localrepo: lookup now goes through context
Matt Mackall <mpm@selenic.com>
parents: 16371
diff changeset
   705
        return self[key].node()
67
a182f2561c8e Add tag support
mpm@selenic.com
parents: 65
diff changeset
   706
10960
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   707
    def lookupbranch(self, key, remote=None):
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   708
        repo = remote or self
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   709
        if key in repo.branchmap():
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   710
            return key
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   711
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   712
        repo = (remote and remote.local()) and remote or self
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   713
        return repo[key].branch()
ca739acf1a98 commands: add more robust support for 'hg log -b' (issue2078)
Steve Losh <steve@stevelosh.com>
parents: 10926
diff changeset
   714
13723
e615765fdcc7 wireproto: add known([id]) function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13720
diff changeset
   715
    def known(self, nodes):
e615765fdcc7 wireproto: add known([id]) function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13720
diff changeset
   716
        nm = self.changelog.nodemap
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16646
diff changeset
   717
        pc = self._phasecache
15889
816209eaf963 phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15888
diff changeset
   718
        result = []
816209eaf963 phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15888
diff changeset
   719
        for n in nodes:
816209eaf963 phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15888
diff changeset
   720
            r = nm.get(n)
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16646
diff changeset
   721
            resp = not (r is None or pc.phase(self, r) >= phases.secret)
15889
816209eaf963 phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15888
diff changeset
   722
            result.append(resp)
816209eaf963 phases: make secret changeset undiscoverable in all case
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15888
diff changeset
   723
        return result
13723
e615765fdcc7 wireproto: add known([id]) function
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13720
diff changeset
   724
926
b765e970c9ff Add a local() method to repository classes
mpm@selenic.com
parents: 923
diff changeset
   725
    def local(self):
14603
68a43fdd7d80 localrepo: local() returns self
Matt Mackall <mpm@selenic.com>
parents: 14549
diff changeset
   726
        return self
926
b765e970c9ff Add a local() method to repository classes
mpm@selenic.com
parents: 923
diff changeset
   727
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   728
    def cancopy(self):
20332
a959f7167077 clone: do not turn hidden changeset public on publishing clone (issue3935)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 20314
diff changeset
   729
        # so statichttprepo's override of local() works
a959f7167077 clone: do not turn hidden changeset public on publishing clone (issue3935)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 20314
diff changeset
   730
        if not self.local():
a959f7167077 clone: do not turn hidden changeset public on publishing clone (issue3935)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 20314
diff changeset
   731
            return False
a959f7167077 clone: do not turn hidden changeset public on publishing clone (issue3935)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 20314
diff changeset
   732
        if not self.ui.configbool('phases', 'publish', True):
a959f7167077 clone: do not turn hidden changeset public on publishing clone (issue3935)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 20314
diff changeset
   733
            return True
a959f7167077 clone: do not turn hidden changeset public on publishing clone (issue3935)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 20314
diff changeset
   734
        # if publishing we can't copy if there is filtered content
a959f7167077 clone: do not turn hidden changeset public on publishing clone (issue3935)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 20314
diff changeset
   735
        return not self.filtered('visible').changelog.filteredrevs
17192
1ac628cd7113 peer: introduce real peer classes
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 17183
diff changeset
   736
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   737
    def join(self, f):
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   738
        return os.path.join(self.path, f)
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   739
244
43105253cf5e root relative IO and valid commit states
mpm@selenic.com
parents: 241
diff changeset
   740
    def wjoin(self, f):
43105253cf5e root relative IO and valid commit states
mpm@selenic.com
parents: 241
diff changeset
   741
        return os.path.join(self.root, f)
43105253cf5e root relative IO and valid commit states
mpm@selenic.com
parents: 241
diff changeset
   742
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   743
    def file(self, f):
1615
83238c1db6de Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1597
diff changeset
   744
        if f[0] == '/':
83238c1db6de Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1597
diff changeset
   745
            f = f[1:]
4258
b11a2fb59cf5 revlog: simplify revlog version handling
Matt Mackall <mpm@selenic.com>
parents: 4232
diff changeset
   746
        return filelog.filelog(self.sopener, f)
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
   747
6739
c9fbd6ec3489 context: avoid using None for working parent
Matt Mackall <mpm@selenic.com>
parents: 6736
diff changeset
   748
    def changectx(self, changeid):
6747
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   749
        return self[changeid]
3218
8d4855fd9d7b merge: use new working context object in update
Matt Mackall <mpm@selenic.com>
parents: 3164
diff changeset
   750
3163
1605e336d229 Add localrepo.parents to get parent changectxs.
Matt Mackall <mpm@selenic.com>
parents: 3132
diff changeset
   751
    def parents(self, changeid=None):
6742
2d54e7c1e69d context: clean up parents()
Matt Mackall <mpm@selenic.com>
parents: 6740
diff changeset
   752
        '''get list of changectxs for parents of changeid'''
6747
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
   753
        return self[changeid].parents()
3163
1605e336d229 Add localrepo.parents to get parent changectxs.
Matt Mackall <mpm@selenic.com>
parents: 3132
diff changeset
   754
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   755
    def setparents(self, p1, p2=nullid):
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   756
        copies = self.dirstate.setparents(p1, p2)
18739
5b7175377bab setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents: 18520
diff changeset
   757
        pctx = self[p1]
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   758
        if copies:
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   759
            # Adjust copy records, the dirstate cannot do it, it
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   760
            # requires access to parents manifests. Preserve them
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   761
            # only for entries added to first parent.
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   762
            for f in copies:
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   763
                if f not in pctx and copies[f] in pctx:
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   764
                    self.dirstate.copy(copies[f], f)
18739
5b7175377bab setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents: 18520
diff changeset
   765
        if p2 == nullid:
5b7175377bab setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents: 18520
diff changeset
   766
            for f, s in sorted(self.dirstate.copies().items()):
5b7175377bab setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents: 18520
diff changeset
   767
                if f not in pctx and s not in pctx:
5b7175377bab setparents: drop copies from dropped p2 (issue3843)
Matt Mackall <mpm@selenic.com>
parents: 18520
diff changeset
   768
                    self.dirstate.copy(None, f)
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16536
diff changeset
   769
2564
55e592041076 Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents: 2491
diff changeset
   770
    def filectx(self, path, changeid=None, fileid=None):
55e592041076 Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents: 2491
diff changeset
   771
        """changeid can be a changeset revision, node, or tag.
55e592041076 Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents: 2491
diff changeset
   772
           fileid can be a file revision or node."""
55e592041076 Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents: 2491
diff changeset
   773
        return context.filectx(self, path, changeid, fileid)
55e592041076 Add context helper functions to localrepo
Matt Mackall <mpm@selenic.com>
parents: 2491
diff changeset
   774
627
b6c42714d900 Add locate command.
Bryan O'Sullivan <bos@serpentine.com>
parents: 624
diff changeset
   775
    def getcwd(self):
870
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
   776
        return self.dirstate.getcwd()
627
b6c42714d900 Add locate command.
Bryan O'Sullivan <bos@serpentine.com>
parents: 624
diff changeset
   777
4525
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4516
diff changeset
   778
    def pathto(self, f, cwd=None):
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4516
diff changeset
   779
        return self.dirstate.pathto(f, cwd)
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4516
diff changeset
   780
291
2c4f2be05587 Add wopener for opening files in the working directory
mpm@selenic.com
parents: 288
diff changeset
   781
    def wfile(self, f, mode='r'):
2c4f2be05587 Add wopener for opening files in the working directory
mpm@selenic.com
parents: 288
diff changeset
   782
        return self.wopener(f, mode)
2c4f2be05587 Add wopener for opening files in the working directory
mpm@selenic.com
parents: 288
diff changeset
   783
4275
81402b2b294d use os.path.islink instead of util.is_link; remove util.is_link
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4273
diff changeset
   784
    def _link(self, f):
18949
138978f20180 localrepo: use "vfs.islink()" instead of "os.path.islink()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18948
diff changeset
   785
        return self.wvfs.islink(f)
4275
81402b2b294d use os.path.islink instead of util.is_link; remove util.is_link
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4273
diff changeset
   786
11698
9df481f8036d localrepo: refactor filter computation
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11669
diff changeset
   787
    def _loadfilter(self, filter):
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   788
        if filter not in self.filterpats:
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   789
            l = []
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   790
            for pat, cmd in self.ui.configitems(filter):
7226
b71a52f101dc Make it possible to disable filtering for a pattern.
Mads Kiilerich <mads@kiilerich.com>
parents: 7208
diff changeset
   791
                if cmd == '!':
b71a52f101dc Make it possible to disable filtering for a pattern.
Mads Kiilerich <mads@kiilerich.com>
parents: 7208
diff changeset
   792
                    continue
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
   793
                mf = matchmod.match(self.root, '', [pat])
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   794
                fn = None
6066
f3a8b5360100 Strip filter name from command before passing to filter function.
Jesse Glick <jesse.glick@sun.com>
parents: 6065
diff changeset
   795
                params = cmd
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   796
                for name, filterfn in self._datafilters.iteritems():
6210
942287cb1f57 Removed trailing spaces from everything except test output
Thomas Arendsen Hein <thomas@intevation.de>
parents: 6201
diff changeset
   797
                    if cmd.startswith(name):
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   798
                        fn = filterfn
6066
f3a8b5360100 Strip filter name from command before passing to filter function.
Jesse Glick <jesse.glick@sun.com>
parents: 6065
diff changeset
   799
                        params = cmd[len(name):].lstrip()
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   800
                        break
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   801
                if not fn:
5967
f8ad3b76e923 Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents: 5966
diff changeset
   802
                    fn = lambda s, c, **kwargs: util.filter(s, c)
f8ad3b76e923 Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents: 5966
diff changeset
   803
                # Wrap old filters not supporting keyword arguments
f8ad3b76e923 Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents: 5966
diff changeset
   804
                if not inspect.getargspec(fn)[2]:
f8ad3b76e923 Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents: 5966
diff changeset
   805
                    oldfn = fn
f8ad3b76e923 Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents: 5966
diff changeset
   806
                    fn = lambda s, c, **kwargs: oldfn(s, c)
6066
f3a8b5360100 Strip filter name from command before passing to filter function.
Jesse Glick <jesse.glick@sun.com>
parents: 6065
diff changeset
   807
                l.append((mf, fn, params))
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   808
            self.filterpats[filter] = l
12706
9ca08fbb750a localrepo: have _loadfilter return the loaded filter patterns
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12687
diff changeset
   809
        return self.filterpats[filter]
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   810
12707
2216ab103ea8 localrepo: load filter patterns outside of _filter
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12706
diff changeset
   811
    def _filter(self, filterpats, filename, data):
2216ab103ea8 localrepo: load filter patterns outside of _filter
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12706
diff changeset
   812
        for mf, fn, cmd in filterpats:
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   813
            if mf(filename):
9467
4c041f1ee1b4 do not attempt to translate ui.debug output
Martin Geisler <mg@lazybytes.net>
parents: 9437
diff changeset
   814
                self.ui.debug("filtering %s through %s\n" % (filename, cmd))
5967
f8ad3b76e923 Provide better context for custom Python encode/decode filters.
Jesse Glick <jesse.glick@sun.com>
parents: 5966
diff changeset
   815
                data = fn(data, cmd, ui=self.ui, repo=self, filename=filename)
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   816
                break
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   817
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   818
        return data
1019
a9cca981c423 Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents: 1013
diff changeset
   819
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   820
    @unfilteredpropertycache
12708
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   821
    def _encodefilterpats(self):
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   822
        return self._loadfilter('encode')
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   823
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   824
    @unfilteredpropertycache
12708
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   825
    def _decodefilterpats(self):
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   826
        return self._loadfilter('decode')
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   827
5966
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   828
    def adddatafilter(self, name, filter):
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   829
        self._datafilters[name] = filter
11af38a592ae Register data filters in a localrepo instead of util
Patrick Mezard <pmezard@gmail.com>
parents: 5915
diff changeset
   830
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   831
    def wread(self, filename):
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   832
        if self._link(filename):
18950
647e3b0c8751 localrepo: use "vfs.readlink()" instead of "os.readlink()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18949
diff changeset
   833
            data = self.wvfs.readlink(filename)
4004
c83c35f2f4e2 unify encode/decode filter routines
Matt Mackall <mpm@selenic.com>
parents: 4003
diff changeset
   834
        else:
14168
135e244776f0 prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 14162
diff changeset
   835
            data = self.wopener.read(filename)
12708
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   836
        return self._filter(self._encodefilterpats, filename, data)
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   837
4006
67982d3ee76c symlinks: add flags param to wwrite
Matt Mackall <mpm@selenic.com>
parents: 4005
diff changeset
   838
    def wwrite(self, filename, data, flags):
12708
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   839
        data = self._filter(self._decodefilterpats, filename, data)
6877
1d38f3605b20 util: set_flags shouldn't know about repo flag formats
Matt Mackall <mpm@selenic.com>
parents: 6875
diff changeset
   840
        if 'l' in flags:
1d38f3605b20 util: set_flags shouldn't know about repo flag formats
Matt Mackall <mpm@selenic.com>
parents: 6875
diff changeset
   841
            self.wopener.symlink(data, filename)
1d38f3605b20 util: set_flags shouldn't know about repo flag formats
Matt Mackall <mpm@selenic.com>
parents: 6875
diff changeset
   842
        else:
14184
4ab6e2d597cc fix errors reported by pyflakes test
Sune Foldager <cryo@cyanite.org>
parents: 14168
diff changeset
   843
            self.wopener.write(filename, data)
6877
1d38f3605b20 util: set_flags shouldn't know about repo flag formats
Matt Mackall <mpm@selenic.com>
parents: 6875
diff changeset
   844
            if 'x' in flags:
18951
d13916a00b7e localrepo: use "vfs.setflags()" instead of "util.setflags()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18950
diff changeset
   845
                self.wvfs.setflags(filename, False, True)
1258
1945754e466b Add file encoding/decoding support
mpm@selenic.com
parents: 1236
diff changeset
   846
4005
656e06eebda7 replace filehandle version of wwrite with wwritedata
Matt Mackall <mpm@selenic.com>
parents: 4004
diff changeset
   847
    def wwritedata(self, filename, data):
12708
8a08b12ae88e localrepo: use propertycaches to access encode/decode filters
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 12707
diff changeset
   848
        return self._filter(self._decodefilterpats, filename, data)
1019
a9cca981c423 Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents: 1013
diff changeset
   849
19853
eddc2a2d57e6 localrepo: make report level in repo.transaction configurable
David Soria Parra <dsp@experimentalworks.net>
parents: 19852
diff changeset
   850
    def transaction(self, desc, report=None):
8072
ecf7795479d5 transaction: support multiple, separate transactions
Henrik Stuart <henrik.stuart@edlund.dk>
parents: 7948
diff changeset
   851
        tr = self._transref and self._transref() or None
ecf7795479d5 transaction: support multiple, separate transactions
Henrik Stuart <henrik.stuart@edlund.dk>
parents: 7948
diff changeset
   852
        if tr and tr.running():
ecf7795479d5 transaction: support multiple, separate transactions
Henrik Stuart <henrik.stuart@edlund.dk>
parents: 7948
diff changeset
   853
            return tr.nest()
1806
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
   854
5865
e7127f669edb transactions: don't show a backtrace when journal exists
Matt Mackall <mpm@selenic.com>
parents: 5814
diff changeset
   855
        # abort here if the journal already exists
18947
9b82f93e3a7a localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18946
diff changeset
   856
        if self.svfs.exists("journal"):
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   857
            raise error.RepoError(
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   858
                _("abandoned transaction found - run hg recover"))
5865
e7127f669edb transactions: don't show a backtrace when journal exists
Matt Mackall <mpm@selenic.com>
parents: 5814
diff changeset
   859
20883
cd443c7589cc fncache: move fncache writing to be in a transaction
Durham Goode <durham@fb.com>
parents: 20880
diff changeset
   860
        def onclose():
cd443c7589cc fncache: move fncache writing to be in a transaction
Durham Goode <durham@fb.com>
parents: 20880
diff changeset
   861
            self.store.write(tr)
cd443c7589cc fncache: move fncache writing to be in a transaction
Durham Goode <durham@fb.com>
parents: 20880
diff changeset
   862
16236
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   863
        self._writejournal(desc)
18952
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
   864
        renames = [(vfs, x, undoname(x)) for vfs, x in self._journalfiles()]
19853
eddc2a2d57e6 localrepo: make report level in repo.transaction configurable
David Soria Parra <dsp@experimentalworks.net>
parents: 19852
diff changeset
   865
        rp = report and report or self.ui.warn
eddc2a2d57e6 localrepo: make report level in repo.transaction configurable
David Soria Parra <dsp@experimentalworks.net>
parents: 19852
diff changeset
   866
        tr = transaction.transaction(rp, self.sopener,
20087
cf3b8285af00 transaction: take journal file path relative to vfs to use file API via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20082
diff changeset
   867
                                     "journal",
14266
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   868
                                     aftertrans(renames),
20883
cd443c7589cc fncache: move fncache writing to be in a transaction
Durham Goode <durham@fb.com>
parents: 20880
diff changeset
   869
                                     self.store.createmode,
cd443c7589cc fncache: move fncache writing to be in a transaction
Durham Goode <durham@fb.com>
parents: 20880
diff changeset
   870
                                     onclose)
14266
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   871
        self._transref = weakref.ref(tr)
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   872
        return tr
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   873
16236
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   874
    def _journalfiles(self):
18952
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
   875
        return ((self.svfs, 'journal'),
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
   876
                (self.vfs, 'journal.dirstate'),
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
   877
                (self.vfs, 'journal.branch'),
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
   878
                (self.vfs, 'journal.desc'),
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
   879
                (self.vfs, 'journal.bookmarks'),
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
   880
                (self.svfs, 'journal.phaseroots'))
16236
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   881
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   882
    def undofiles(self):
20975
37cdf1fca1b2 localrepo: make "undofiles()" return list of tuples "(vfs, relative filename)"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20969
diff changeset
   883
        return [(vfs, undoname(x)) for vfs, x in self._journalfiles()]
16236
97efd26eb957 localrepo: refactor retrieving of journal/undo files paths
Idan Kamara <idankk86@gmail.com>
parents: 16208
diff changeset
   884
14266
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   885
    def _writejournal(self, desc):
16456
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   886
        self.opener.write("journal.dirstate",
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   887
                          self.opener.tryread("dirstate"))
14168
135e244776f0 prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 14162
diff changeset
   888
        self.opener.write("journal.branch",
135e244776f0 prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 14162
diff changeset
   889
                          encoding.fromlocal(self.dirstate.branch()))
135e244776f0 prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 14162
diff changeset
   890
        self.opener.write("journal.desc",
135e244776f0 prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents: 14162
diff changeset
   891
                          "%d\n%s\n" % (len(self), desc))
16456
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   892
        self.opener.write("journal.bookmarks",
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   893
                          self.opener.tryread("bookmarks"))
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   894
        self.sopener.write("journal.phaseroots",
42862d64aa8f journal: use tryread helper to backup files (issue3375)
Matt Mackall <mpm@selenic.com>
parents: 16441
diff changeset
   895
                           self.sopener.tryread("phaseroots"))
14266
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
   896
210
d2badbd7d1ad hg undo: fixup working dir state
mpm@selenic.com
parents: 207
diff changeset
   897
    def recover(self):
8109
496ae1ea4698 switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8108
diff changeset
   898
        lock = self.lock()
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   899
        try:
18947
9b82f93e3a7a localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18946
diff changeset
   900
            if self.svfs.exists("journal"):
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   901
                self.ui.status(_("rolling back interrupted transaction\n"))
20087
cf3b8285af00 transaction: take journal file path relative to vfs to use file API via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20082
diff changeset
   902
                transaction.rollback(self.sopener, "journal",
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
   903
                                     self.ui.warn)
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   904
                self.invalidate()
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   905
                return True
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   906
            else:
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   907
                self.ui.warn(_("no interrupted transaction available\n"))
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   908
                return False
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   909
        finally:
8109
496ae1ea4698 switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8108
diff changeset
   910
            lock.release()
210
d2badbd7d1ad hg undo: fixup working dir state
mpm@selenic.com
parents: 207
diff changeset
   911
15183
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   912
    def rollback(self, dryrun=False, force=False):
4917
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
   913
        wlock = lock = None
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   914
        try:
1712
21dcf38e5d7d Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents: 1709
diff changeset
   915
            wlock = self.wlock()
4438
3900f684a150 Fix hg import --exact bug that hangs hg on failure.
Eric Hopper <hopper@omnifarious.org>
parents: 4417
diff changeset
   916
            lock = self.lock()
18947
9b82f93e3a7a localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18946
diff changeset
   917
            if self.svfs.exists("undo"):
15183
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   918
                return self._rollback(dryrun, force)
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   919
            else:
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   920
                self.ui.warn(_("no rollback information available\n"))
11177
6a64813276ed commands: initial audit of exit codes
Matt Mackall <mpm@selenic.com>
parents: 11174
diff changeset
   921
                return 1
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
   922
        finally:
8109
496ae1ea4698 switch lock releasing in the core from gc to explicit
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8108
diff changeset
   923
            release(lock, wlock)
162
5dcbe4d9a30c Implement recover and undo commands
mpm@selenic.com
parents: 161
diff changeset
   924
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
   925
    @unfilteredmethod # Until we get smarter cache management
15183
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   926
    def _rollback(self, dryrun, force):
15130
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   927
        ui = self.ui
15097
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   928
        try:
15130
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   929
            args = self.opener.read('undo.desc').splitlines()
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   930
            (oldlen, desc, detail) = (int(args[0]), args[1], None)
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   931
            if len(args) >= 3:
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   932
                detail = args[2]
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   933
            oldtip = oldlen - 1
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   934
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   935
            if detail and ui.verbose:
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   936
                msg = (_('repository tip rolled back to revision %s'
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   937
                         ' (undo %s: %s)\n')
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   938
                       % (oldtip, desc, detail))
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   939
            else:
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   940
                msg = (_('repository tip rolled back to revision %s'
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   941
                         ' (undo %s)\n')
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   942
                       % (oldtip, desc))
15097
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   943
        except IOError:
15130
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   944
            msg = _('rolling back unknown transaction\n')
15183
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   945
            desc = None
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   946
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   947
        if not force and self['.'] != self['tip'] and desc == 'commit':
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   948
            raise util.Abort(
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   949
                _('rollback of last commit while not checked out '
15187
0292f88d3b86 rollback: use a hint for force
Matt Mackall <mpm@selenic.com>
parents: 15183
diff changeset
   950
                  'may lose data'), hint=_('use -f to force'))
15183
59e8bc22506e rollback: avoid unsafe rollback when not at tip (issue2998)
Greg Ward <greg@gerg.ca>
parents: 15131
diff changeset
   951
15130
3d44e68360a6 rollback: refactor for readability; cosmetics.
Greg Ward <greg@gerg.ca>
parents: 15101
diff changeset
   952
        ui.status(msg)
15097
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   953
        if dryrun:
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   954
            return 0
15131
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   955
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   956
        parents = self.dirstate.parents()
18310
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
   957
        self.destroying()
20087
cf3b8285af00 transaction: take journal file path relative to vfs to use file API via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20082
diff changeset
   958
        transaction.rollback(self.sopener, 'undo', ui.warn)
18947
9b82f93e3a7a localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18946
diff changeset
   959
        if self.vfs.exists('undo.bookmarks'):
18948
2f05fa162316 localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18947
diff changeset
   960
            self.vfs.rename('undo.bookmarks', 'bookmarks')
18947
9b82f93e3a7a localrepo: use "vfs.exists()" instead of "os.path.exists()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18946
diff changeset
   961
        if self.svfs.exists('undo.phaseroots'):
18948
2f05fa162316 localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18947
diff changeset
   962
            self.svfs.rename('undo.phaseroots', 'phaseroots')
15097
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   963
        self.invalidate()
15131
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   964
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   965
        parentgone = (parents[0] not in self.changelog.nodemap or
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   966
                      parents[1] not in self.changelog.nodemap)
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   967
        if parentgone:
18948
2f05fa162316 localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18947
diff changeset
   968
            self.vfs.rename('undo.dirstate', 'dirstate')
15131
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   969
            try:
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   970
                branch = self.opener.read('undo.branch')
17360
935831597e16 rollback: write dirstate branch with correct encoding
Sune Foldager <cryo@cyanite.org>
parents: 17324
diff changeset
   971
                self.dirstate.setbranch(encoding.tolocal(branch))
15131
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   972
            except IOError:
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   973
                ui.warn(_('named branch could not be reset: '
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   974
                          'current branch is still \'%s\'\n')
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   975
                        % self.dirstate.branch())
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   976
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   977
            self.dirstate.invalidate()
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   978
            parents = tuple([p.rev() for p in self.parents()])
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   979
            if len(parents) > 1:
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   980
                ui.status(_('working directory now based on '
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   981
                            'revisions %d and %d\n') % parents)
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   982
            else:
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   983
                ui.status(_('working directory now based on '
7c26ce9edbd2 rollback: only restore dirstate and branch when appropriate.
Greg Ward <greg@gerg.ca>
parents: 15130
diff changeset
   984
                            'revision %d\n') % parents)
17013
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
   985
        # TODO: if we know which new heads may result from this rollback, pass
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
   986
        # them to destroy(), which will prevent the branchhead cache from being
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
   987
        # invalidated.
15604
b8d8599410da rollback: always call destroyed() (regression from 1.9)
Greg Ward <greg-hg@gerg.ca>
parents: 15381
diff changeset
   988
        self.destroyed()
15097
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   989
        return 0
cda7a87c1871 rollback: improve readability; clarify that the return value is an int.
Greg Ward <greg-hg@gerg.ca>
parents: 15057
diff changeset
   990
10547
bae9bb09166b strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10522
diff changeset
   991
    def invalidatecaches(self):
15988
827e0126738d localrepo: delete _phaserev when invalidating caches
Idan Kamara <idankk86@gmail.com>
parents: 15987
diff changeset
   992
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   993
        if '_tagscache' in vars(self):
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   994
            # can't use delattr on proxy
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
   995
            del self.__dict__['_tagscache']
14936
9dca7653b525 localrepo: unify tag related info into a tagscache class
Idan Kamara <idankk86@gmail.com>
parents: 14935
diff changeset
   996
18189
b9026ba002f6 branchmap: enable caching for filtered version too
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18186
diff changeset
   997
        self.unfiltered()._branchcaches.clear()
18105
312262ebc223 cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18101
diff changeset
   998
        self.invalidatevolatilesets()
312262ebc223 cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18101
diff changeset
   999
312262ebc223 cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18101
diff changeset
  1000
    def invalidatevolatilesets(self):
312262ebc223 cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18101
diff changeset
  1001
        self.filteredrevcache.clear()
17469
fb72eec7efd8 obsolete: introduce caches for all meaningful sets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17434
diff changeset
  1002
        obsolete.clearobscaches(self)
1784
2e0a288ca93e revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1782
diff changeset
  1003
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1004
    def invalidatedirstate(self):
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1005
        '''Invalidates the dirstate, causing the next call to dirstate
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1006
        to check if it was modified since the last time it was read,
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1007
        rereading it if it has.
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1008
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1009
        This is different to dirstate.invalidate() that it doesn't always
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1010
        rereads the dirstate. Use dirstate.invalidate() if you want to
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1011
        explicitly read the dirstate again (i.e. restoring it to a previous
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1012
        known good state).'''
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
  1013
        if hasunfilteredcache(self, 'dirstate'):
16200
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16198
diff changeset
  1014
            for k in self.dirstate._filecache:
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16198
diff changeset
  1015
                try:
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16198
diff changeset
  1016
                    delattr(self.dirstate, k)
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16198
diff changeset
  1017
                except AttributeError:
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16198
diff changeset
  1018
                    pass
17997
6089956e9880 clfilter: ensure cache invalidation is done on the main unfiltered repo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17996
diff changeset
  1019
            delattr(self.unfiltered(), 'dirstate')
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1020
10547
bae9bb09166b strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10522
diff changeset
  1021
    def invalidate(self):
18644
3e92772d5383 spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents: 18520
diff changeset
  1022
        unfiltered = self.unfiltered() # all file caches are stored unfiltered
14935
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1023
        for k in self._filecache:
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1024
            # dirstate is invalidated separately in invalidatedirstate()
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1025
            if k == 'dirstate':
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1026
                continue
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1027
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1028
            try:
17997
6089956e9880 clfilter: ensure cache invalidation is done on the main unfiltered repo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17996
diff changeset
  1029
                delattr(unfiltered, k)
14935
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1030
            except AttributeError:
4ae7473f5b73 localrepo: make invalidate() walk _filecache
Idan Kamara <idankk86@gmail.com>
parents: 14934
diff changeset
  1031
                pass
10547
bae9bb09166b strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10522
diff changeset
  1032
        self.invalidatecaches()
20884
2efdd186925d caches: invalidate store caches when lock is taken
Durham Goode <durham@fb.com>
parents: 20883
diff changeset
  1033
        self.store.invalidatecaches()
10547
bae9bb09166b strip: invalidate all caches after stripping (fixes issue1951)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10522
diff changeset
  1034
20627
a42ea6d209e6 localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents: 20567
diff changeset
  1035
    def invalidateall(self):
a42ea6d209e6 localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents: 20567
diff changeset
  1036
        '''Fully invalidates both store and non-store parts, causing the
a42ea6d209e6 localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents: 20567
diff changeset
  1037
        subsequent operation to reread any outside changes.'''
a42ea6d209e6 localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents: 20567
diff changeset
  1038
        # extension should hook this to invalidate its caches
a42ea6d209e6 localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents: 20567
diff changeset
  1039
        self.invalidate()
a42ea6d209e6 localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents: 20567
diff changeset
  1040
        self.invalidatedirstate()
a42ea6d209e6 localrepo: add hook point to invalidate everything on each command-server run
Yuya Nishihara <yuya@tcha.org>
parents: 20567
diff changeset
  1041
20091
abfe6a8e619b lock: take both vfs and lock file path relative to vfs to access via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20088
diff changeset
  1042
    def _lock(self, vfs, lockname, wait, releasefn, acquirefn, desc):
161
0b4c5cb953d9 Simply repository locking
mpm@selenic.com
parents: 155
diff changeset
  1043
        try:
20091
abfe6a8e619b lock: take both vfs and lock file path relative to vfs to access via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20088
diff changeset
  1044
            l = lockmod.lock(vfs, lockname, 0, releasefn, desc=desc)
7640
7197812e8d44 error: move lock errors
Matt Mackall <mpm@selenic.com>
parents: 7637
diff changeset
  1045
        except error.LockHeld, inst:
1531
2ba8bf7defda add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1516
diff changeset
  1046
            if not wait:
2016
ff5c9a92f556 fix backtrace printed when cannot get lock.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1998
diff changeset
  1047
                raise
3688
d92dad355000 Corrected "waiting for lock on repository FOO held by BAR" message.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3687
diff changeset
  1048
            self.ui.warn(_("waiting for lock on %s held by %r\n") %
d92dad355000 Corrected "waiting for lock on repository FOO held by BAR" message.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3687
diff changeset
  1049
                         (desc, inst.locker))
2016
ff5c9a92f556 fix backtrace printed when cannot get lock.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 1998
diff changeset
  1050
            # default to 600 seconds timeout
20091
abfe6a8e619b lock: take both vfs and lock file path relative to vfs to access via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20088
diff changeset
  1051
            l = lockmod.lock(vfs, lockname,
20088
7cbb79bddee7 localrepo: import "lock" module as "lockmod" for readability
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20087
diff changeset
  1052
                             int(self.ui.config("ui", "timeout", "600")),
7cbb79bddee7 localrepo: import "lock" module as "lockmod" for readability
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20087
diff changeset
  1053
                             releasefn, desc=desc)
20380
c697b70f295f localrepo: give a sigh of relief when getting lock after waiting for it
Mads Kiilerich <madski@unity3d.com>
parents: 20364
diff changeset
  1054
            self.ui.warn(_("got lock after %s seconds\n") % l.delay)
1751
e9bf415a8ecb localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1747
diff changeset
  1055
        if acquirefn:
e9bf415a8ecb localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1747
diff changeset
  1056
            acquirefn()
e9bf415a8ecb localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1747
diff changeset
  1057
        return l
e9bf415a8ecb localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1747
diff changeset
  1058
15587
809d5d30e377 localrepo: rename _postrelease to _afterlock
Matt Mackall <mpm@selenic.com>
parents: 15586
diff changeset
  1059
    def _afterlock(self, callback):
15583
926a06f7a353 lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15486
diff changeset
  1060
        """add a callback to the current repository lock.
926a06f7a353 lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15486
diff changeset
  1061
926a06f7a353 lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15486
diff changeset
  1062
        The callback will be executed on lock release."""
926a06f7a353 lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15486
diff changeset
  1063
        l = self._lockref and self._lockref()
15588
632f4be4d1f3 localrepo: remove asserts in _afterlock
Matt Mackall <mpm@selenic.com>
parents: 15587
diff changeset
  1064
        if l:
15589
cc24e4ed3e0c lock: change name of release chain
Matt Mackall <mpm@selenic.com>
parents: 15588
diff changeset
  1065
            l.postrelease.append(callback)
16680
d0e419b0f7de tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents: 16679
diff changeset
  1066
        else:
d0e419b0f7de tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents: 16679
diff changeset
  1067
            callback()
15583
926a06f7a353 lock: add mechanism to register post release callback
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15486
diff changeset
  1068
4914
9a2a73ea6135 repo locks: use True/False
Matt Mackall <mpm@selenic.com>
parents: 4913
diff changeset
  1069
    def lock(self, wait=True):
9309
cfdcb7a465af localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents: 9152
diff changeset
  1070
        '''Lock the repository store (.hg/store) and return a weak reference
cfdcb7a465af localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents: 9152
diff changeset
  1071
        to the lock. Use this before modifying the store (e.g. committing or
cfdcb7a465af localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents: 9152
diff changeset
  1072
        stripping). If you are opening a transaction, get a lock as well.)'''
8108
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1073
        l = self._lockref and self._lockref()
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1074
        if l is not None and l.held:
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1075
            l.lock()
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1076
            return l
4917
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1077
14931
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1078
        def unlock():
18013
98c867ac1330 clfilter: add a propertycache that must be unfiltered
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18009
diff changeset
  1079
            if hasunfilteredcache(self, '_phasecache'):
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16646
diff changeset
  1080
                self._phasecache.write()
14931
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1081
            for k, ce in self._filecache.items():
18309
cfeab932cff7 localrepo: don't refresh filecache entries that aren't in __dict__
Idan Kamara <idankk86@gmail.com>
parents: 18305
diff changeset
  1082
                if k == 'dirstate' or k not in self.__dict__:
14931
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1083
                    continue
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1084
                ce.refresh()
a710936c3037 localrepo: refresh filecache entries after releasing a repo.lock()
Idan Kamara <idankk86@gmail.com>
parents: 14930
diff changeset
  1085
20091
abfe6a8e619b lock: take both vfs and lock file path relative to vfs to access via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20088
diff changeset
  1086
        l = self._lock(self.svfs, "lock", wait, unlock,
13391
d00bbff8600e fncachestore: defer updating the fncache file to a single file open
Adrian Buehlmann <adrian@cadifra.com>
parents: 13390
diff changeset
  1087
                       self.invalidate, _('repository %s') % self.origroot)
4917
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1088
        self._lockref = weakref.ref(l)
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1089
        return l
1751
e9bf415a8ecb localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1747
diff changeset
  1090
4914
9a2a73ea6135 repo locks: use True/False
Matt Mackall <mpm@selenic.com>
parents: 4913
diff changeset
  1091
    def wlock(self, wait=True):
9309
cfdcb7a465af localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents: 9152
diff changeset
  1092
        '''Lock the non-store parts of the repository (everything under
cfdcb7a465af localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents: 9152
diff changeset
  1093
        .hg except .hg/store) and return a weak reference to the lock.
cfdcb7a465af localrepo: document the locking scheme a little better
Greg Ward <greg-hg@gerg.ca>
parents: 9152
diff changeset
  1094
        Use this before modifying files in .hg.'''
8108
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1095
        l = self._wlockref and self._wlockref()
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1096
        if l is not None and l.held:
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1097
            l.lock()
a26d33749bd8 made repo locks recursive and deprecate refcounting based lock releasing
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 8072
diff changeset
  1098
            return l
1531
2ba8bf7defda add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1516
diff changeset
  1099
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1100
        def unlock():
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1101
            self.dirstate.write()
18318
948f495fb230 localrepo: drop unnecessary check on wlock unlock
Idan Kamara <idankk86@gmail.com>
parents: 18314
diff changeset
  1102
            self._filecache['dirstate'].refresh()
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1103
20091
abfe6a8e619b lock: take both vfs and lock file path relative to vfs to access via vfs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20088
diff changeset
  1104
        l = self._lock(self.vfs, "wlock", wait, unlock,
14930
372d9d8b1da4 localrepo: decorate dirstate() with filecache
Idan Kamara <idankk86@gmail.com>
parents: 14929
diff changeset
  1105
                       self.invalidatedirstate, _('working directory of %s') %
4917
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1106
                       self.origroot)
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1107
        self._wlockref = weakref.ref(l)
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1108
        return l
1531
2ba8bf7defda add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1516
diff changeset
  1109
8401
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1110
    def _filecommit(self, fctx, manifest1, manifest2, linkrev, tr, changelist):
3292
764688cf51e5 merge: remember rename copies and parents properly on commit
Matt Mackall <mpm@selenic.com>
parents: 3241
diff changeset
  1111
        """
3294
a2d93b186a0e commit: unify file-level commit code
Matt Mackall <mpm@selenic.com>
parents: 3293
diff changeset
  1112
        commit an individual file as part of a larger transaction
a2d93b186a0e commit: unify file-level commit code
Matt Mackall <mpm@selenic.com>
parents: 3293
diff changeset
  1113
        """
3292
764688cf51e5 merge: remember rename copies and parents properly on commit
Matt Mackall <mpm@selenic.com>
parents: 3241
diff changeset
  1114
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1115
        fname = fctx.path()
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1116
        text = fctx.data()
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1117
        flog = self.file(fname)
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1118
        fparent1 = manifest1.get(fname, nullid)
8401
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1119
        fparent2 = fparent2o = manifest2.get(fname, nullid)
1716
ef8cd889a78b Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents: 1713
diff changeset
  1120
3292
764688cf51e5 merge: remember rename copies and parents properly on commit
Matt Mackall <mpm@selenic.com>
parents: 3241
diff changeset
  1121
        meta = {}
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1122
        copy = fctx.renamed()
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1123
        if copy and copy[0] != fname:
4058
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1124
            # Mark the new revision of this file as a copy of another
4516
96d8a56d4ef9 Removed trailing whitespace and tabs from python files
Thomas Arendsen Hein <thomas@intevation.de>
parents: 4510
diff changeset
  1125
            # file.  This copy data will effectively act as a parent
96d8a56d4ef9 Removed trailing whitespace and tabs from python files
Thomas Arendsen Hein <thomas@intevation.de>
parents: 4510
diff changeset
  1126
            # of this new revision.  If this is a merge, the first
4058
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1127
            # parent will be the nullid (meaning "look up the copy data")
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1128
            # and the second one will be the other parent.  For example:
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1129
            #
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1130
            # 0 --- 1 --- 3   rev1 changes file foo
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1131
            #   \       /     rev2 renames foo to bar and changes it
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1132
            #    \- 2 -/      rev3 should have bar with all changes and
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1133
            #                      should record that bar descends from
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1134
            #                      bar in rev2 and foo in rev1
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1135
            #
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1136
            # this allows this merge to succeed:
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1137
            #
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1138
            # 0 --- 1 --- 3   rev4 reverts the content change from rev2
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1139
            #   \       /     merging rev3 and rev4 should use bar@rev2
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1140
            #    \- 2 --- 4        as the merge base
e7282dede8cd filecommit: don't forget the local parent on a merge with a local rename
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 3923
diff changeset
  1141
            #
6874
8dc21876261e commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents: 6680
diff changeset
  1142
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1143
            cfname = copy[0]
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1144
            crev = manifest1.get(cfname)
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1145
            newfparent = fparent2
6874
8dc21876261e commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents: 6680
diff changeset
  1146
8dc21876261e commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents: 6680
diff changeset
  1147
            if manifest2: # branch merge
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1148
                if fparent2 == nullid or crev is None: # copied on remote side
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1149
                    if cfname in manifest2:
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1150
                        crev = manifest2[cfname]
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1151
                        newfparent = fparent1
6874
8dc21876261e commit: simplify file copy logic
Matt Mackall <mpm@selenic.com>
parents: 6680
diff changeset
  1152
6875
0d714a48ab53 add a fix for issue 1175
Matt Mackall <mpm@selenic.com>
parents: 6874
diff changeset
  1153
            # find source in nearest ancestor if we've lost track
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1154
            if not crev:
9467
4c041f1ee1b4 do not attempt to translate ui.debug output
Martin Geisler <mg@lazybytes.net>
parents: 9437
diff changeset
  1155
                self.ui.debug(" %s: searching for copy revision for %s\n" %
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1156
                              (fname, cfname))
13000
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1157
                for ancestor in self[None].ancestors():
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1158
                    if cfname in ancestor:
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1159
                        crev = ancestor[cfname].filenode()
6876
077f1e637cd8 Merge with stable
Matt Mackall <mpm@selenic.com>
parents: 6875 6840
diff changeset
  1160
                        break
6875
0d714a48ab53 add a fix for issue 1175
Matt Mackall <mpm@selenic.com>
parents: 6874
diff changeset
  1161
13000
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1162
            if crev:
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1163
                self.ui.debug(" %s: copy %s:%s\n" % (fname, cfname, hex(crev)))
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1164
                meta["copy"] = cfname
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1165
                meta["copyrev"] = hex(crev)
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1166
                fparent1, fparent2 = nullid, newfparent
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1167
            else:
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1168
                self.ui.warn(_("warning: can't find ancestor for '%s' "
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1169
                               "copied from '%s'!\n") % (fname, cfname))
417f3c27983b commit: search both parents for missing copy revision (issue2484)
Matt Mackall <mpm@selenic.com>
parents: 12899
diff changeset
  1170
20556
db0740a487ab localrepo: commit: avoid calling expensive ancestor function when p1 is nullrev
Mads Kiilerich <madski@unity3d.com>
parents: 20469
diff changeset
  1171
        elif fparent1 == nullid:
db0740a487ab localrepo: commit: avoid calling expensive ancestor function when p1 is nullrev
Mads Kiilerich <madski@unity3d.com>
parents: 20469
diff changeset
  1172
            fparent1, fparent2 = fparent2, nullid
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1173
        elif fparent2 != nullid:
1716
ef8cd889a78b Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents: 1713
diff changeset
  1174
            # is one parent an ancestor of the other?
21106
53433d8f1faa localrepo: use commonancestorsheads for checking linear heritage in file commit
Mads Kiilerich <madski@unity3d.com>
parents: 21071
diff changeset
  1175
            fparentancestors = flog.commonancestorsheads(fparent1, fparent2)
20987
298c9f346dde commit: use revlog.commonancestors instead of .ancestor
Mads Kiilerich <madski@unity3d.com>
parents: 20975
diff changeset
  1176
            if fparent1 in fparentancestors:
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1177
                fparent1, fparent2 = fparent2, nullid
20987
298c9f346dde commit: use revlog.commonancestors instead of .ancestor
Mads Kiilerich <madski@unity3d.com>
parents: 20975
diff changeset
  1178
            elif fparent2 in fparentancestors:
8244
99d7e2db8da8 localrepo: Refactor var names in filecommit to improve readability.
Martijn Pieters <mj@zopatista.com>
parents: 8239
diff changeset
  1179
                fparent2 = nullid
1716
ef8cd889a78b Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents: 1713
diff changeset
  1180
8401
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1181
        # is the file changed?
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1182
        if fparent2 != nullid or flog.cmp(fparent1, text) or meta:
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1183
            changelist.append(fname)
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1184
            return flog.add(text, meta, tr, linkrev, fparent1, fparent2)
1716
ef8cd889a78b Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents: 1713
diff changeset
  1185
8401
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1186
        # are just the flags changed during merge?
10320
808c187fc556 localrepo: minor formatting - remove double space
Henri Wiechers <hwiechers@gmail.com>
parents: 10282
diff changeset
  1187
        if fparent1 != fparent2o and manifest1.flags(fname) != fctx.flags():
8401
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1188
            changelist.append(fname)
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1189
ca7dc47eecc6 filecommit: swallow some bits from _commitctx, add _
Matt Mackall <mpm@selenic.com>
parents: 8400
diff changeset
  1190
        return fparent1
1716
ef8cd889a78b Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents: 1713
diff changeset
  1191
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
  1192
    @unfilteredmethod
8706
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1193
    def commit(self, text="", user=None, date=None, match=None, force=False,
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1194
               editor=False, extra={}):
8515
865e08a7d6b0 localrepo: update commit*() docstrings
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 8503
diff changeset
  1195
        """Add a new revision to current repository.
865e08a7d6b0 localrepo: update commit*() docstrings
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 8503
diff changeset
  1196
8706
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1197
        Revision information is gathered from the working directory,
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1198
        match can be used to filter the committed files. If editor is
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1199
        supplied, it is called to get a commit message.
8515
865e08a7d6b0 localrepo: update commit*() docstrings
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 8503
diff changeset
  1200
        """
8709
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1201
8715
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1202
        def fail(f, msg):
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1203
            raise util.Abort('%s: %s' % (f, msg))
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1204
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1205
        if not match:
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
  1206
            match = matchmod.always(self.root, '')
8715
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1207
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1208
        if not force:
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1209
            vdirs = []
19138
e579687cb5d8 localrepo.commit: hook into match.explicitdir
Siddharth Agarwal <sid0@fb.com>
parents: 19097
diff changeset
  1210
            match.explicitdir = vdirs.append
8715
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1211
            match.bad = fail
8c667f4c482e commit: move some setup outside the lock
Matt Mackall <mpm@selenic.com>
parents: 8712
diff changeset
  1212
8405
7cbf8fcd2453 commit: push repo lock down into _commitctx
Matt Mackall <mpm@selenic.com>
parents: 8404
diff changeset
  1213
        wlock = self.wlock()
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1214
        try:
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1215
            wctx = self[None]
10970
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1216
            merge = len(wctx.parents()) > 1
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
  1217
10970
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1218
            if (not force and merge and match and
8501
ab0e3f7ea315 commit: some tidying
Matt Mackall <mpm@selenic.com>
parents: 8500
diff changeset
  1219
                (match.files() or match.anypats())):
8397
613ac2856535 remove deprecated rawcommit
Matt Mackall <mpm@selenic.com>
parents: 8395
diff changeset
  1220
                raise util.Abort(_('cannot partially commit a merge '
613ac2856535 remove deprecated rawcommit
Matt Mackall <mpm@selenic.com>
parents: 8395
diff changeset
  1221
                                   '(do not specify files or patterns)'))
6706
716a1296e182 localrepo: replace dirstate by workingfilectx in filecommit()
Patrick Mezard <pmezard@gmail.com>
parents: 6705
diff changeset
  1222
8706
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1223
            changes = self.status(match=match, clean=force)
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1224
            if force:
25e9c71b89de commit: drop the now-unused files parameter
Matt Mackall <mpm@selenic.com>
parents: 8705
diff changeset
  1225
                changes[0].extend(changes[6]) # mq may commit unchanged files
3621
7d3d603e7df9 localrepo: factor commit and rawcommit
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3620
diff changeset
  1226
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1227
            # check subrepos
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1228
            subs = []
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1229
            commitsubs = set()
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1230
            newstate = wctx.substate.copy()
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1231
            # only manage subrepos and .hgsubstate if .hgsub is present
14536
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1232
            if '.hgsub' in wctx:
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1233
                # we'll decide whether to track this ourselves, thanks
20827
ca5dd216cb62 localrepo: omit ".hgsubstate" also from "added" files
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20776
diff changeset
  1234
                for c in changes[:3]:
ca5dd216cb62 localrepo: omit ".hgsubstate" also from "added" files
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20776
diff changeset
  1235
                    if '.hgsubstate' in c:
ca5dd216cb62 localrepo: omit ".hgsubstate" also from "added" files
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20776
diff changeset
  1236
                        c.remove('.hgsubstate')
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1237
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1238
                # compare current state to last committed state
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1239
                # build new substate based on last committed state
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1240
                oldstate = wctx.p1().substate
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1241
                for s in sorted(newstate.keys()):
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1242
                    if not match(s):
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1243
                        # ignore working copy, use old state if present
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1244
                        if s in oldstate:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1245
                            newstate[s] = oldstate[s]
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1246
                            continue
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1247
                        if not force:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1248
                            raise util.Abort(
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1249
                                _("commit with new subrepo %s excluded") % s)
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1250
                    if wctx.sub(s).dirty(True):
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1251
                        if not self.ui.configbool('ui', 'commitsubrepos'):
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1252
                            raise util.Abort(
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1253
                                _("uncommitted changes in subrepo %s") % s,
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1254
                                hint=_("use --subrepos for recursive commit"))
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1255
                        subs.append(s)
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1256
                        commitsubs.add(s)
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1257
                    else:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1258
                        bs = wctx.sub(s).basestate()
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1259
                        newstate[s] = (newstate[s][0], bs, newstate[s][2])
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1260
                        if oldstate.get(s, (None, None, None))[1] != bs:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1261
                            subs.append(s)
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1262
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1263
                # check for removed subrepos
14536
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1264
                for p in wctx.parents():
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1265
                    r = [s for s in p.substate if s not in newstate]
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1266
                    subs += [s for s in r if match(s)]
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1267
                if subs:
14536
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1268
                    if (not match('.hgsub') and
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1269
                        '.hgsub' in (wctx.modified() + wctx.added())):
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1270
                        raise util.Abort(
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1271
                            _("can't commit subrepos without .hgsub"))
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1272
                    changes[0].insert(0, '.hgsubstate')
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1273
14536
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1274
            elif '.hgsub' in changes[2]:
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1275
                # clean up .hgsubstate when .hgsub is removed
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1276
                if ('.hgsubstate' in wctx and
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1277
                    '.hgsubstate' not in changes[0] + changes[1] + changes[2]):
52cbeb5a651b subrepo: be more careful with deletions of .hgsub and .hgsubstate (issue2844)
Matt Mackall <mpm@selenic.com>
parents: 14529
diff changeset
  1278
                    changes[2].insert(0, '.hgsubstate')
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1279
8709
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1280
            # make sure all explicit patterns are matched
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1281
            if not force and match.files():
8710
bcb6e5bebd93 commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents: 8709
diff changeset
  1282
                matched = set(changes[0] + changes[1] + changes[2])
8709
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1283
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1284
                for f in match.files():
17378
b05e517c2236 commit: normalize filenames when checking explicit files (issue3576)
Matt Mackall <mpm@selenic.com>
parents: 17360
diff changeset
  1285
                    f = self.dirstate.normalize(f)
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1286
                    if f == '.' or f in matched or f in wctx.substate:
8709
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1287
                        continue
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1288
                    if f in changes[3]: # missing
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1289
                        fail(f, _('file not found!'))
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1290
                    if f in vdirs: # visited directory
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1291
                        d = f + '/'
8710
bcb6e5bebd93 commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents: 8709
diff changeset
  1292
                        for mf in matched:
bcb6e5bebd93 commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents: 8709
diff changeset
  1293
                            if mf.startswith(d):
bcb6e5bebd93 commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents: 8709
diff changeset
  1294
                                break
bcb6e5bebd93 commit: trade O(n^2) file checks for O(n^2) dir checks
Matt Mackall <mpm@selenic.com>
parents: 8709
diff changeset
  1295
                        else:
8709
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1296
                            fail(f, _("no match under directory!"))
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1297
                    elif f not in self.dirstate:
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1298
                        fail(f, _("file not tracked!"))
b9e0ddb04c5c commit: move explicit file checking into repo.commit
Matt Mackall <mpm@selenic.com>
parents: 8707
diff changeset
  1299
18659
b946470efed9 localrepo: create context used for actual commit earlier
David Schleimer <dschleimer@fb.com>
parents: 18644
diff changeset
  1300
            cctx = context.workingctx(self, text, user, date, extra, changes)
b946470efed9 localrepo: create context used for actual commit earlier
David Schleimer <dschleimer@fb.com>
parents: 18644
diff changeset
  1301
10970
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1302
            if (not force and not extra.get("close") and not merge
18660
7e6946ed5756 localrepo: use workingctx for validation in commit
David Schleimer <dschleimer@fb.com>
parents: 18659
diff changeset
  1303
                and not cctx.files()
10970
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1304
                and wctx.branch() == wctx.p1().branch()):
8404
a2bc39ade36b commit: move 'nothing changed' test into commit()
Matt Mackall <mpm@selenic.com>
parents: 8403
diff changeset
  1305
                return None
a2bc39ade36b commit: move 'nothing changed' test into commit()
Matt Mackall <mpm@selenic.com>
parents: 8403
diff changeset
  1306
18660
7e6946ed5756 localrepo: use workingctx for validation in commit
David Schleimer <dschleimer@fb.com>
parents: 18659
diff changeset
  1307
            if merge and cctx.deleted():
16536
63c817ea4a70 commit: abort on merge with missing files
Patrick Mezard <patrick@mezard.eu>
parents: 16456
diff changeset
  1308
                raise util.Abort(_("cannot commit merge with missing files"))
63c817ea4a70 commit: abort on merge with missing files
Patrick Mezard <patrick@mezard.eu>
parents: 16456
diff changeset
  1309
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
  1310
            ms = mergemod.mergestate(self)
6888
7c36a4fb05a3 make commit fail when committing unresolved files
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents: 6884
diff changeset
  1311
            for f in changes[0]:
7c36a4fb05a3 make commit fail when committing unresolved files
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents: 6884
diff changeset
  1312
                if f in ms and ms[f] == 'u':
7c36a4fb05a3 make commit fail when committing unresolved files
Stefano Tortarolo <stefano.tortarolo@gmail.com>
parents: 6884
diff changeset
  1313
                    raise util.Abort(_("unresolved merge conflicts "
13541
919174c0aaff Improve unresolved merge conflicts warning (issue2681)
Patrick Mezard <pmezard@gmail.com>
parents: 13526
diff changeset
  1314
                                       "(see hg help resolve)"))
8496
a21605de1509 commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents: 8481
diff changeset
  1315
a21605de1509 commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents: 8481
diff changeset
  1316
            if editor:
8994
4a1187d3cb00 commit: report modified subrepos in commit editor
Matt Mackall <mpm@selenic.com>
parents: 8954
diff changeset
  1317
                cctx._text = editor(self, cctx, subs)
9935
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1318
            edited = (text != cctx._text)
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1319
20765
f042d4b263f4 localrepo: save manually edited commit message as soon as possible
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20332
diff changeset
  1320
            # Save commit message in case this transaction gets rolled back
f042d4b263f4 localrepo: save manually edited commit message as soon as possible
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20332
diff changeset
  1321
            # (e.g. by a pretxncommit hook).  Leave the content alone on
f042d4b263f4 localrepo: save manually edited commit message as soon as possible
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20332
diff changeset
  1322
            # the assumption that the user will use the same editor again.
f042d4b263f4 localrepo: save manually edited commit message as soon as possible
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20332
diff changeset
  1323
            msgfn = self.savecommitmessage(cctx._text)
f042d4b263f4 localrepo: save manually edited commit message as soon as possible
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20332
diff changeset
  1324
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1325
            # commit subs and write new state
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1326
            if subs:
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1327
                for s in sorted(commitsubs):
11112
4a9bee613737 subrepo: print paths relative to upper repo root for push/pull/commit
Edouard Gomez <ed.gomez@free.fr>
parents: 11063
diff changeset
  1328
                    sub = wctx.sub(s)
4a9bee613737 subrepo: print paths relative to upper repo root for push/pull/commit
Edouard Gomez <ed.gomez@free.fr>
parents: 11063
diff changeset
  1329
                    self.ui.status(_('committing subrepository %s\n') %
12752
18b5b6392fcf subrepo: rename relpath to subrelpath and introduce reporelpath
Mads Kiilerich <mads@kiilerich.com>
parents: 12708
diff changeset
  1330
                        subrepo.subrelpath(sub))
11112
4a9bee613737 subrepo: print paths relative to upper repo root for push/pull/commit
Edouard Gomez <ed.gomez@free.fr>
parents: 11063
diff changeset
  1331
                    sr = sub.commit(cctx._text, user, date)
16073
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1332
                    newstate[s] = (newstate[s][0], sr)
b254f827b7a6 subrepo: rewrite handling of subrepo state at commit (issue2403)
Matt Mackall <mpm@selenic.com>
parents: 16030
diff changeset
  1333
                subrepo.writestate(self, newstate)
8813
db3c1ab0e632 commit: recurse into subrepositories
Matt Mackall <mpm@selenic.com>
parents: 8799
diff changeset
  1334
10970
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1335
            p1, p2 = self.dirstate.parents()
3213e8947975 localrepo.commit: use explicit variables, avoid creating new contexts
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10969
diff changeset
  1336
            hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or '')
9935
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1337
            try:
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1338
                self.hook("precommit", throw=True, parent1=hookp1,
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1339
                          parent2=hookp2)
9935
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1340
                ret = self.commitctx(cctx, True)
16705
c2d9ef43ff6c check-code: ignore naked excepts with a "re-raise" comment
Brodie Rao <brodie@sf.io>
parents: 16699
diff changeset
  1341
            except: # re-raises
9935
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1342
                if edited:
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1343
                    self.ui.write(
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1344
                        _('note: commit message saved in %s\n') % msgfn)
48b81d9bca8d commit: if relevant, tell user their commit message was saved.
Greg Ward <greg-hg@gerg.ca>
parents: 9934
diff changeset
  1345
                raise
8496
a21605de1509 commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents: 8481
diff changeset
  1346
13357
b67867940bd1 bookmarks: move commit action into core
Matt Mackall <mpm@selenic.com>
parents: 13356
diff changeset
  1347
            # update bookmarks, dirstate and mergestate
16706
a270ec977ba6 bookmarks: delete divergent bookmarks on merge
David Soria Parra <dsp@php.net>
parents: 16705
diff changeset
  1348
            bookmarks.update(self, [p1, p2], ret)
18661
4fb92f14a97a commit: factor out post-commit cleanup into workingctx
David Schleimer <dschleimer@fb.com>
parents: 18660
diff changeset
  1349
            cctx.markcommitted(ret)
8503
90f86a5330bb commit: tidy up mergestate slightly
Matt Mackall <mpm@selenic.com>
parents: 8502
diff changeset
  1350
            ms.reset()
6710
0aa91f69a4c4 localrepo: extract _commitctx() from commit()
Patrick Mezard <pmezard@gmail.com>
parents: 6709
diff changeset
  1351
        finally:
8405
7cbf8fcd2453 commit: push repo lock down into _commitctx
Matt Mackall <mpm@selenic.com>
parents: 8404
diff changeset
  1352
            wlock.release()
6710
0aa91f69a4c4 localrepo: extract _commitctx() from commit()
Patrick Mezard <pmezard@gmail.com>
parents: 6709
diff changeset
  1353
16680
d0e419b0f7de tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents: 16679
diff changeset
  1354
        def commithook(node=hex(ret), parent1=hookp1, parent2=hookp2):
d0e419b0f7de tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents: 16679
diff changeset
  1355
            self.hook("commit", node=node, parent1=parent1, parent2=parent2)
d0e419b0f7de tag: run commit hook when lock is released (issue3344)
Mads Kiilerich <mads@kiilerich.com>
parents: 16679
diff changeset
  1356
        self._afterlock(commithook)
10492
0e64d814d7d0 run commit and update hooks after command completion (issue1827)
Sune Foldager <cryo@cyanite.org>
parents: 10435
diff changeset
  1357
        return ret
0e64d814d7d0 run commit and update hooks after command completion (issue1827)
Sune Foldager <cryo@cyanite.org>
parents: 10435
diff changeset
  1358
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
  1359
    @unfilteredmethod
8496
a21605de1509 commit: move editor outside transaction
Matt Mackall <mpm@selenic.com>
parents: 8481
diff changeset
  1360
    def commitctx(self, ctx, error=False):
7077
ccbd39cad3c3 context: improve memctx documentation
Patrick Mezard <pmezard@gmail.com>
parents: 7072
diff changeset
  1361
        """Add a new revision to current repository.
8410
1d11d985c179 commit: combine _commitctx and commitctx, drop unused force argument
Matt Mackall <mpm@selenic.com>
parents: 8407
diff changeset
  1362
        Revision information is passed via the context argument.
7077
ccbd39cad3c3 context: improve memctx documentation
Patrick Mezard <pmezard@gmail.com>
parents: 7072
diff changeset
  1363
        """
6715
a3c41abfa828 context: add memctx for memory commits
Patrick Mezard <pmezard@gmail.com>
parents: 6712
diff changeset
  1364
8412
2bf4f380f6ab commitctx: eliminate some variables
Matt Mackall <mpm@selenic.com>
parents: 8411
diff changeset
  1365
        tr = lock = None
12899
fabe61418a53 localrepo: do not modify ctx.remove() list in-place
Patrick Mezard <pmezard@gmail.com>
parents: 12847
diff changeset
  1366
        removed = list(ctx.removed())
8414
2348ce25849b commitctx: use contexts more fully
Matt Mackall <mpm@selenic.com>
parents: 8412
diff changeset
  1367
        p1, p2 = ctx.p1(), ctx.p2()
8412
2bf4f380f6ab commitctx: eliminate some variables
Matt Mackall <mpm@selenic.com>
parents: 8411
diff changeset
  1368
        user = ctx.user()
990
5007e0bdeed2 Fix long-standing excessive file merges
mpm@selenic.com
parents: 981
diff changeset
  1369
8411
4d5916358abd commit: move lots of commitctx outside of the repo lock
Matt Mackall <mpm@selenic.com>
parents: 8410
diff changeset
  1370
        lock = self.lock()
4d5916358abd commit: move lots of commitctx outside of the repo lock
Matt Mackall <mpm@selenic.com>
parents: 8410
diff changeset
  1371
        try:
10881
a685011ed38e localrepo: add desc parameter to transaction
Steve Borho <steve@borho.org>
parents: 10877
diff changeset
  1372
            tr = self.transaction("commit")
4970
30d4d8985dd8 transactions: avoid late tear-down (issue641)
Matt Mackall <mpm@selenic.com>
parents: 4917
diff changeset
  1373
            trp = weakref.proxy(tr)
151
1f6c61a60586 Bail on attempts to do an empty commit
mpm@selenic.com
parents: 149
diff changeset
  1374
14162
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1375
            if ctx.files():
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1376
                m1 = p1.manifest().copy()
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1377
                m2 = p2.manifest()
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1378
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1379
                # check in files
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1380
                new = {}
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1381
                changed = []
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1382
                linkrev = len(self)
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1383
                for f in sorted(ctx.modified() + ctx.added()):
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1384
                    self.ui.note(f + "\n")
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1385
                    try:
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1386
                        fctx = ctx[f]
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1387
                        new[f] = self._filecommit(fctx, m1, m2, linkrev, trp,
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1388
                                                  changed)
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1389
                        m1.set(f, fctx.flags())
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1390
                    except OSError, inst:
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1391
                        self.ui.warn(_("trouble committing %s!\n") % f)
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1392
                        raise
14162
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1393
                    except IOError, inst:
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1394
                        errcode = getattr(inst, 'errno', errno.ENOENT)
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1395
                        if error or errcode and errcode != errno.ENOENT:
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1396
                            self.ui.warn(_("trouble committing %s!\n") % f)
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1397
                            raise
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1398
                        else:
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1399
                            removed.append(f)
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
  1400
14162
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1401
                # update manifest
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1402
                m1.update(new)
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1403
                removed = [f for f in sorted(removed) if f in m1 or f in m2]
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1404
                drop = [f for f in removed if f in m1]
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1405
                for f in drop:
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1406
                    del m1[f]
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1407
                mn = self.manifest.add(m1, trp, linkrev, p1.manifestnode(),
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1408
                                       p2.manifestnode(), (new, drop))
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1409
                files = changed + removed
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1410
            else:
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1411
                mn = p1.manifestnode()
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1412
                files = []
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
  1413
8499
fb9b83df45f3 commit: move description trimming into changelog
Matt Mackall <mpm@selenic.com>
parents: 8498
diff changeset
  1414
            # update changelog
7787
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  1415
            self.changelog.delayupdate()
14162
301725c3df9a localrepo: reuse parent manifest in commitctx if no files have changed
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14155
diff changeset
  1416
            n = self.changelog.add(mn, files, ctx.description(),
8499
fb9b83df45f3 commit: move description trimming into changelog
Matt Mackall <mpm@selenic.com>
parents: 8498
diff changeset
  1417
                                   trp, p1.node(), p2.node(),
8412
2bf4f380f6ab commitctx: eliminate some variables
Matt Mackall <mpm@selenic.com>
parents: 8411
diff changeset
  1418
                                   user, ctx.date(), ctx.extra().copy())
7787
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  1419
            p = lambda: self.changelog.writepending() and self.root or ""
10492
0e64d814d7d0 run commit and update hooks after command completion (issue1827)
Sune Foldager <cryo@cyanite.org>
parents: 10435
diff changeset
  1420
            xp1, xp2 = p1.hex(), p2 and p2.hex() or ''
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1421
            self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
7787
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  1422
                      parent2=xp2, pending=p)
b8d750daadde Introduce HG_PREPEND to solve pretxn races
Matt Mackall <mpm@selenic.com>
parents: 7728
diff changeset
  1423
            self.changelog.finalize(trp)
15706
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1424
            # set the new commit is proper phase
20176
4c96c50ef937 subrepo: check phase of state in each subrepositories before committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20091
diff changeset
  1425
            targetphase = subrepo.newcommitphase(self.ui, ctx)
15706
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1426
            if targetphase:
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1427
                # retract boundary do not alter parent changeset.
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1428
                # if a parent have higher the resulting phase will
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1429
                # be compliant anyway
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1430
                #
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1431
                # if minimal phase was 0 we don't need to retract anything
ebaefd8c6028 Add a phases.new-commit option to control minimal phase of new commit
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15659
diff changeset
  1432
                phases.retractboundary(self, targetphase, [n])
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1433
            tr.close()
18394
5010448197bc branchmap: update cache of 'unserved' filter on new changesets
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18382
diff changeset
  1434
            branchmap.updatecache(self.filtered('served'))
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1435
            return n
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1436
        finally:
11230
5116a077c3da make transactions work on non-refcounted python implementations
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 11228
diff changeset
  1437
            if tr:
5116a077c3da make transactions work on non-refcounted python implementations
Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de>
parents: 11228
diff changeset
  1438
                tr.release()
8405
7cbf8fcd2453 commit: push repo lock down into _commitctx
Matt Mackall <mpm@selenic.com>
parents: 8404
diff changeset
  1439
            lock.release()
660
2c83350784c3 Move commit hook after commit completes
Matt Mackall <mpm@selenic.com>
parents: 659
diff changeset
  1440
18016
2a393df0f5cc clfilter: rename `unfilteredmeth` to `unfilteredmethod`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18014
diff changeset
  1441
    @unfilteredmethod
18310
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1442
    def destroying(self):
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1443
        '''Inform the repository that nodes are about to be destroyed.
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1444
        Intended for use by strip and rollback, so there's a common
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1445
        place for anything that has to be done before destroying history.
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1446
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1447
        This is mostly useful for saving state that is in memory and waiting
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1448
        to be flushed when the current lock is released. Because a call to
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1449
        destroyed is imminent, the repo will be invalidated causing those
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1450
        changes to stay in memory (waiting for the next unlock), or vanish
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1451
        completely.
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1452
        '''
18312
7331ee72f99c localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents: 18311
diff changeset
  1453
        # When using the same lock to commit and strip, the phasecache is left
7331ee72f99c localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents: 18311
diff changeset
  1454
        # dirty after committing. Then when we strip, the repo is invalidated,
7331ee72f99c localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents: 18311
diff changeset
  1455
        # causing those changes to disappear.
7331ee72f99c localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents: 18311
diff changeset
  1456
        if '_phasecache' in vars(self):
7331ee72f99c localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents: 18311
diff changeset
  1457
            self._phasecache.write()
7331ee72f99c localrepo: write the phasecache when destroying nodes
Idan Kamara <idankk86@gmail.com>
parents: 18311
diff changeset
  1458
18310
4499ba5ac35c localrepo: introduce destroying function
Idan Kamara <idankk86@gmail.com>
parents: 18309
diff changeset
  1459
    @unfilteredmethod
18395
904b7109938e destroyed: drop complex branchcache rebuilt logic
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18394
diff changeset
  1460
    def destroyed(self):
9150
09a1ee498756 localrepo: add destroyed() method for strip/rollback to use (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9149
diff changeset
  1461
        '''Inform the repository that nodes have been destroyed.
09a1ee498756 localrepo: add destroyed() method for strip/rollback to use (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9149
diff changeset
  1462
        Intended for use by strip and rollback, so there's a common
17013
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1463
        place for anything that has to be done after destroying history.
c8eda7bbdcab strip: incrementally update the branchheads cache after a strip
Joshua Redstone <joshua.redstone@fb.com>
parents: 17012
diff changeset
  1464
        '''
18221
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1465
        # When one tries to:
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1466
        # 1) destroy nodes thus calling this method (e.g. strip)
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1467
        # 2) use phasecache somewhere (e.g. commit)
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1468
        #
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1469
        # then 2) will fail because the phasecache contains nodes that were
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1470
        # removed. We can either remove phasecache from the filecache,
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1471
        # causing it to reload next time it is accessed, or simply filter
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1472
        # the removed nodes now and write the updated cache.
18757
1c8e0d6ac3b0 localrepo: always write the filtered phasecache when nodes are destroyed (issue3827)
Idan Kamara <idankk86@gmail.com>
parents: 18739
diff changeset
  1473
        self._phasecache.filterunknown(self)
1c8e0d6ac3b0 localrepo: always write the filtered phasecache when nodes are destroyed (issue3827)
Idan Kamara <idankk86@gmail.com>
parents: 18739
diff changeset
  1474
        self._phasecache.write()
18221
082d6929fd4d localrepo: filter unknown nodes from the phasecache on destroyed
Idan Kamara <idankk86@gmail.com>
parents: 18219
diff changeset
  1475
18396
dd3fd3353e23 destroyed: update `unserved` branchcache instead
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18395
diff changeset
  1476
        # update the 'served' branch cache to help read only server process
18644
3e92772d5383 spelling: fix some minor issues found by spell checker
Mads Kiilerich <mads@kiilerich.com>
parents: 18520
diff changeset
  1477
        # Thanks to branchcache collaboration this is done from the nearest
18396
dd3fd3353e23 destroyed: update `unserved` branchcache instead
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18395
diff changeset
  1478
        # filtered subset and it is expected to be fast.
dd3fd3353e23 destroyed: update `unserved` branchcache instead
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18395
diff changeset
  1479
        branchmap.updatecache(self.filtered('served'))
18223
6d6d0248530b destroyed: filter unknown before computing branchcache
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18222
diff changeset
  1480
9151
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1481
        # Ensure the persistent tag cache is updated.  Doing it now
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1482
        # means that the tag cache only has to worry about destroyed
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1483
        # heads immediately after a strip/rollback.  That in turn
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1484
        # guarantees that "cachetip == currenttip" (comparing both rev
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1485
        # and node) always means no nodes have been added or destroyed.
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1486
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1487
        # XXX this is suboptimal when qrefresh'ing: we strip the current
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1488
        # head, refresh the tag cache, then immediately add a new head.
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1489
        # But I think doing it this way is necessary for the "instant
f528d1a93491 tags: implement persistent tag caching (issue548).
Greg Ward <greg-hg@gerg.ca>
parents: 9150
diff changeset
  1490
        # tag cache retrieval" case to work.
18313
3e4a944c0d04 destroyed: keep the filecache in sync with __dict__ (issue3335) (issue3693) (issue3743)
Idan Kamara <idankk86@gmail.com>
parents: 18312
diff changeset
  1491
        self.invalidate()
17324
9f94358f9f93 localrepo: clear the filecache on _rollback() and destroyed()
Idan Kamara <idankk86@gmail.com>
parents: 17306
diff changeset
  1492
6585
d3d1d39da2fa walk: remove cmdutil.walk
Matt Mackall <mpm@selenic.com>
parents: 6583
diff changeset
  1493
    def walk(self, match, node=None):
3532
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1494
        '''
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1495
        walk recursively through the directory tree or a given
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1496
        changeset, finding all files matched by the match
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1497
        function
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1498
        '''
6764
8db64464d136 context: add walk method
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
  1499
        return self[node].walk(match)
3532
26b556c1d01d improve walk docstrings
Matt Mackall <mpm@selenic.com>
parents: 3513
diff changeset
  1500
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1501
    def status(self, node1='.', node2=None, match=None,
12166
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1502
               ignored=False, clean=False, unknown=False,
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1503
               listsubrepos=False):
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1504
        """return status of files between two nodes or node and working
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1505
        directory.
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1506
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1507
        If node1 is None, use the first dirstate parent instead.
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1508
        If node2 is None, compare node1 with working directory.
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1509
        """
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
  1510
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1511
        def mfmatches(ctx):
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1512
            mf = ctx.manifest().copy()
16645
9a21fc2c7d32 localrepo: optimize internode status calls using match.always
Jesse Glick <jesse.glick@oracle.com>
parents: 16628
diff changeset
  1513
            if match.always():
9a21fc2c7d32 localrepo: optimize internode status calls using match.always
Jesse Glick <jesse.glick@oracle.com>
parents: 16628
diff changeset
  1514
                return mf
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
  1515
            for fn in mf.keys():
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
  1516
                if not match(fn):
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
  1517
                    del mf[fn]
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
  1518
            return mf
741
156dc2f3be7f Fix some line wrapping
mpm@selenic.com
parents: 740
diff changeset
  1519
19569
00140039bd8f localrepo: remove unnecessary check of instance
Sean Farley <sean.michael.farley@gmail.com>
parents: 19515
diff changeset
  1520
        ctx1 = self[node1]
00140039bd8f localrepo: remove unnecessary check of instance
Sean Farley <sean.michael.farley@gmail.com>
parents: 19515
diff changeset
  1521
        ctx2 = self[node2]
7090
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1522
7435
5e13df32fb74 bundlerepo doesn't really have a dirstate, throw AttributeError if requested
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents: 7415
diff changeset
  1523
        working = ctx2.rev() is None
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1524
        parentworking = working and ctx1 == self['.']
10651
5f091fc1bab7 style: use consistent variable names (*mod) with imports which would shadow
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10547
diff changeset
  1525
        match = match or matchmod.always(self.root, self.getcwd())
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
  1526
        listignored, listclean, listunknown = ignored, clean, unknown
2474
1e32e2fe8a67 Fix cold cache diff performance
Chris Mason <mason@suse.com>
parents: 2463
diff changeset
  1527
7090
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1528
        # load earliest manifest first for caching reasons
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1529
        if not working and ctx2.rev() < ctx1.rev():
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1530
            ctx2.manifest()
7b5c063b0b94 diff: pass contexts to status
Matt Mackall <mpm@selenic.com>
parents: 7077
diff changeset
  1531
7067
40d105a12cac status: don't warn about missing files present in base revision (issue1323)
Matt Mackall <mpm@selenic.com>
parents: 7064
diff changeset
  1532
        if not parentworking:
40d105a12cac status: don't warn about missing files present in base revision (issue1323)
Matt Mackall <mpm@selenic.com>
parents: 7064
diff changeset
  1533
            def bad(f, msg):
16144
4546a8513dcd localrepository: use 'changectx.dirs()' in 'status()' for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16116
diff changeset
  1534
                # 'f' may be a directory pattern from 'match.files()',
4546a8513dcd localrepository: use 'changectx.dirs()' in 'status()' for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16116
diff changeset
  1535
                # so 'f not in ctx1' is not enough
4546a8513dcd localrepository: use 'changectx.dirs()' in 'status()' for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16116
diff changeset
  1536
                if f not in ctx1 and f not in ctx1.dirs():
7067
40d105a12cac status: don't warn about missing files present in base revision (issue1323)
Matt Mackall <mpm@selenic.com>
parents: 7064
diff changeset
  1537
                    self.ui.warn('%s: %s\n' % (self.dirstate.pathto(f), msg))
40d105a12cac status: don't warn about missing files present in base revision (issue1323)
Matt Mackall <mpm@selenic.com>
parents: 7064
diff changeset
  1538
            match.bad = bad
40d105a12cac status: don't warn about missing files present in base revision (issue1323)
Matt Mackall <mpm@selenic.com>
parents: 7064
diff changeset
  1539
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1540
        if working: # we need to scan the working dir
11227
054549ccb680 status: avoid performance regression when no .hgsub is present
Matt Mackall <mpm@selenic.com>
parents: 11154
diff changeset
  1541
            subrepos = []
054549ccb680 status: avoid performance regression when no .hgsub is present
Matt Mackall <mpm@selenic.com>
parents: 11154
diff changeset
  1542
            if '.hgsub' in self.dirstate:
18364
6252b4f1c4b4 subrepos: process subrepos in sorted order
Mads Kiilerich <mads@kiilerich.com>
parents: 18356
diff changeset
  1543
                subrepos = sorted(ctx2.substate)
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10011
diff changeset
  1544
            s = self.dirstate.status(match, subrepos, listignored,
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10011
diff changeset
  1545
                                     listclean, listunknown)
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1546
            cmp, modified, added, removed, deleted, unknown, ignored, clean = s
536
c15b4bc0a11c Refactor diffrevs/diffdir into changes
mpm@selenic.com
parents: 529
diff changeset
  1547
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1548
            # check for any possibly clean files
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1549
            if parentworking and cmp:
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1550
                fixup = []
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1551
                # do a full compare of any files that might have changed
8395
475552c03496 status: check cmp list in order
Matt Mackall <mpm@selenic.com>
parents: 8393
diff changeset
  1552
                for f in sorted(cmp):
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1553
                    if (f not in ctx1 or ctx2.flags(f) != ctx1.flags(f)
11702
eb07fbc21e9c filectx: use cmp(self, fctx) instead of cmp(self, text)
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11698
diff changeset
  1554
                        or ctx1[f].cmp(ctx2[f])):
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1555
                        modified.append(f)
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1556
                    else:
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1557
                        fixup.append(f)
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1558
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1559
                # update dirstate for files that are actually clean
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1560
                if fixup:
11669
c47cb3193c53 localrepo.status: move fixup concatenation inside if block for clarity
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11665
diff changeset
  1561
                    if listclean:
c47cb3193c53 localrepo.status: move fixup concatenation inside if block for clarity
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11665
diff changeset
  1562
                        clean += fixup
c47cb3193c53 localrepo.status: move fixup concatenation inside if block for clarity
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents: 11665
diff changeset
  1563
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1564
                    try:
8647
cb74433f9b41 localrepo: move comment
Adrian Buehlmann <adrian@cadifra.com>
parents: 8646
diff changeset
  1565
                        # updating the dirstate is optional
cb74433f9b41 localrepo: move comment
Adrian Buehlmann <adrian@cadifra.com>
parents: 8646
diff changeset
  1566
                        # so we don't wait on the lock
8646
60f9e574b6eb localrepo: use lock.release for single lock
Simon Heimberg <simohe@besonet.ch>
parents: 8639
diff changeset
  1567
                        wlock = self.wlock(False)
4915
97b734fb9c6f Use try/finally pattern to cleanup locks and transactions
Matt Mackall <mpm@selenic.com>
parents: 4914
diff changeset
  1568
                        try:
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1569
                            for f in fixup:
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1570
                                self.dirstate.normal(f)
8646
60f9e574b6eb localrepo: use lock.release for single lock
Simon Heimberg <simohe@besonet.ch>
parents: 8639
diff changeset
  1571
                        finally:
60f9e574b6eb localrepo: use lock.release for single lock
Simon Heimberg <simohe@besonet.ch>
parents: 8639
diff changeset
  1572
                            wlock.release()
60f9e574b6eb localrepo: use lock.release for single lock
Simon Heimberg <simohe@besonet.ch>
parents: 8639
diff changeset
  1573
                    except error.LockError:
60f9e574b6eb localrepo: use lock.release for single lock
Simon Heimberg <simohe@besonet.ch>
parents: 8639
diff changeset
  1574
                        pass
2661
5c10b7ed3411 status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2621
diff changeset
  1575
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1576
        if not parentworking:
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1577
            mf1 = mfmatches(ctx1)
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1578
            if working:
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1579
                # we are comparing working dir against non-parent
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1580
                # generate a pseudo-manifest for the working dir
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1581
                mf2 = mfmatches(self['.'])
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1582
                for f in cmp + modified + added:
6769
97c12b1ed1e0 status: use contexts
Matt Mackall <mpm@selenic.com>
parents: 6764
diff changeset
  1583
                    mf2[f] = None
6817
cf319797d61c minor status fixups
Matt Mackall <mpm@selenic.com>
parents: 6810
diff changeset
  1584
                    mf2.set(f, ctx2.flags(f))
1617
ece5d785e87a Make localrepo.changes() internally distinguish between removed and deleted.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1616
diff changeset
  1585
                for f in removed:
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1586
                    if f in mf2:
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1587
                        del mf2[f]
6770
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1588
            else:
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1589
                # we are comparing two revisions
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1590
                deleted, unknown, ignored = [], [], []
854b907527e5 status: various cleanups
Matt Mackall <mpm@selenic.com>
parents: 6769
diff changeset
  1591
                mf2 = mfmatches(ctx2)
4372
4ddc6d374265 localrepository.status: only acquire wlock if actually needed.
Bryan O'Sullivan <bos@serpentine.com>
parents: 4335
diff changeset
  1592
2661
5c10b7ed3411 status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2621
diff changeset
  1593
            modified, added, clean = [], [], []
16646
a1dcd842ce17 localrepo: optimize internode status calls using withflags
Jesse Glick <jesse.glick@oracle.com>
parents: 16645
diff changeset
  1594
            withflags = mf1.withflags() | mf2.withflags()
18714
7790d69af6d6 localrepo: iterate over manifest key/value pairs in status
Bryan O'Sullivan <bryano@fb.com>
parents: 18691
diff changeset
  1595
            for fn, mf2node in mf2.iteritems():
5915
d0576d065993 Prefer i in d over d.has_key(i)
Christian Ebert <blacktrash@gmx.net>
parents: 5913
diff changeset
  1596
                if fn in mf1:
14500
e880433a2e00 localrepo: don't add deleted files to list of modified/added files (issue2761)
Idan Kamara <idankk86@gmail.com>
parents: 14499
diff changeset
  1597
                    if (fn not in deleted and
16646
a1dcd842ce17 localrepo: optimize internode status calls using withflags
Jesse Glick <jesse.glick@oracle.com>
parents: 16645
diff changeset
  1598
                        ((fn in withflags and mf1.flags(fn) != mf2.flags(fn)) or
18714
7790d69af6d6 localrepo: iterate over manifest key/value pairs in status
Bryan O'Sullivan <bryano@fb.com>
parents: 18691
diff changeset
  1599
                         (mf1[fn] != mf2node and
7790d69af6d6 localrepo: iterate over manifest key/value pairs in status
Bryan O'Sullivan <bryano@fb.com>
parents: 18691
diff changeset
  1600
                          (mf2node or ctx1[fn].cmp(ctx2[fn]))))):
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1601
                        modified.append(fn)
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
  1602
                    elif listclean:
2661
5c10b7ed3411 status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2621
diff changeset
  1603
                        clean.append(fn)
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1604
                    del mf1[fn]
14500
e880433a2e00 localrepo: don't add deleted files to list of modified/added files (issue2761)
Idan Kamara <idankk86@gmail.com>
parents: 14499
diff changeset
  1605
                elif fn not in deleted:
1616
f0f9e84849e7 Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1615
diff changeset
  1606
                    added.append(fn)
1617
ece5d785e87a Make localrepo.changes() internally distinguish between removed and deleted.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1616
diff changeset
  1607
            removed = mf1.keys()
ece5d785e87a Make localrepo.changes() internally distinguish between removed and deleted.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1616
diff changeset
  1608
15348
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1609
        if working and modified and not self.dirstate._checklink:
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1610
            # Symlink placeholders may get non-symlink-like contents
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1611
            # via user error or dereferencing by NFS or Samba servers,
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1612
            # so we filter out any placeholders that don't look like a
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1613
            # symlink
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1614
            sane = []
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1615
            for f in modified:
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1616
                if ctx2.flags(f) == 'l':
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1617
                    d = ctx2[f].data()
19650
36f48c7d5944 localrepo.status: ignore empty symlink placeholders
Siddharth Agarwal <sid0@fb.com>
parents: 19635
diff changeset
  1618
                    if d == '' or len(d) >= 1024 or '\n' in d or util.binary(d):
15348
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1619
                        self.ui.debug('ignoring suspect symlink placeholder'
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1620
                                      ' "%s"\n' % f)
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1621
                        continue
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1622
                sane.append(f)
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1623
            modified = sane
c681e478c429 windows: sanity-check symlink placeholders
Matt Mackall <mpm@selenic.com>
parents: 15321
diff changeset
  1624
6827
c978d6752dbb dirstate.walk: push sorting up
Matt Mackall <mpm@selenic.com>
parents: 6817
diff changeset
  1625
        r = modified, added, removed, deleted, unknown, ignored, clean
12166
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1626
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1627
        if listsubrepos:
20392
d4f804caa0ed itersubrepos: move to scmutil to break a direct import cycle
Augie Fackler <raf@durin42.com>
parents: 20380
diff changeset
  1628
            for subpath, sub in scmutil.itersubrepos(ctx1, ctx2):
12166
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1629
                if working:
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1630
                    rev2 = None
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1631
                else:
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1632
                    rev2 = ctx2.substate[subpath][1]
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1633
                try:
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1634
                    submatch = matchmod.narrowmatcher(subpath, match)
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1635
                    s = sub.status(rev2, match=submatch, ignored=listignored,
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1636
                                   clean=listclean, unknown=listunknown,
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1637
                                   listsubrepos=True)
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1638
                    for rfiles, sfiles in zip(r, s):
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1639
                        rfiles.extend("%s/%s" % (subpath, f) for f in sfiles)
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1640
                except error.LookupError:
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1641
                    self.ui.status(_("skipping missing subrepository: %s\n")
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1642
                                   % subpath)
441a74b8def1 status: recurse into subrepositories with --subrepos/-S flag
Martin Geisler <mg@lazybytes.net>
parents: 12162
diff changeset
  1643
13412
58c497d0e44d remove unnecessary list comprehensions
Martin Geisler <mg@aragost.com>
parents: 13411
diff changeset
  1644
        for l in r:
58c497d0e44d remove unnecessary list comprehensions
Martin Geisler <mg@aragost.com>
parents: 13411
diff changeset
  1645
            l.sort()
6827
c978d6752dbb dirstate.walk: push sorting up
Matt Mackall <mpm@selenic.com>
parents: 6817
diff changeset
  1646
        return r
2661
5c10b7ed3411 status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2621
diff changeset
  1647
8796
2bcef677a6c3 localrepo: remove 'closed' argument to heads(...) function
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 8731
diff changeset
  1648
    def heads(self, start=None):
1550
ccb9b62de892 add a -r/--rev option to heads to show only heads descendant from rev
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1532
diff changeset
  1649
        heads = self.changelog.heads(start)
ccb9b62de892 add a -r/--rev option to heads to show only heads descendant from rev
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1532
diff changeset
  1650
        # sort the output in rev descending order
13075
d73c3034deee coding style: fix gratuitous whitespace after Python keywords
Thomas Arendsen Hein <thomas@jtah.de>
parents: 13047
diff changeset
  1651
        return sorted(heads, key=self.changelog.rev, reverse=True)
222
87484f627422 make pull work for multiple heads
mpm@selenic.com
parents: 220
diff changeset
  1652
8694
ca8d05e1f1d1 localrepo: set heads and branchheads to be closed=False by default
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 8680
diff changeset
  1653
    def branchheads(self, branch=None, start=None, closed=False):
9475
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1654
        '''return a (possibly filtered) list of heads for the given branch
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1655
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1656
        Heads are returned in topological order, from newest to oldest.
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1657
        If branch is None, use the dirstate branch.
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1658
        If start is not None, return only heads reachable from start.
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1659
        If closed is True, return heads that are marked as closed as well.
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1660
        '''
6747
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
  1661
        if branch is None:
f6c00b17387c use repo[changeid] to get a changectx
Matt Mackall <mpm@selenic.com>
parents: 6743
diff changeset
  1662
            branch = self[None].branch()
9675
ee913987e4b0 localrepo/branchcache: remove lbranchmap(), convert users to use utf-8 names
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 9674
diff changeset
  1663
        branches = self.branchmap()
4648
8e503fa54d2d Add option to heads to show only heads for current branch.
Eric Hopper <hopper@omnifarious.org>
parents: 4635
diff changeset
  1664
        if branch not in branches:
8e503fa54d2d Add option to heads to show only heads for current branch.
Eric Hopper <hopper@omnifarious.org>
parents: 4635
diff changeset
  1665
            return []
7654
816b708f23af store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7644
diff changeset
  1666
        # the cache returns heads ordered lowest to highest
20189
1831993d0902 localrepo: refactor repo.branchheads() to use repo.branchmap().branchheads()
Brodie Rao <brodie@sf.io>
parents: 20187
diff changeset
  1667
        bheads = list(reversed(branches.branchheads(branch, closed=closed)))
4648
8e503fa54d2d Add option to heads to show only heads for current branch.
Eric Hopper <hopper@omnifarious.org>
parents: 4635
diff changeset
  1668
        if start is not None:
7654
816b708f23af store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7644
diff changeset
  1669
            # filter out the heads that cannot be reached from startrev
9475
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1670
            fbheads = set(self.changelog.nodesbetween([start], bheads)[2])
c295a82a020b localrepo: fix bugs in branchheads and add docstring
Sune Foldager <cryo@cyanite.org>
parents: 9423
diff changeset
  1671
            bheads = [h for h in bheads if h in fbheads]
7654
816b708f23af store all heads of a branch in the branch cache
John Mulligan <phlogistonjohn@asynchrono.us>
parents: 7644
diff changeset
  1672
        return bheads
4648
8e503fa54d2d Add option to heads to show only heads for current branch.
Eric Hopper <hopper@omnifarious.org>
parents: 4635
diff changeset
  1673
56
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1674
    def branches(self, nodes):
1615
83238c1db6de Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1597
diff changeset
  1675
        if not nodes:
83238c1db6de Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents: 1597
diff changeset
  1676
            nodes = [self.changelog.tip()]
56
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1677
        b = []
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1678
        for n in nodes:
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1679
            t = n
14494
1ffeeb91c55d check-code: flag 0/1 used as constant Boolean expression
Martin Geisler <mg@lazybytes.net>
parents: 14482
diff changeset
  1680
            while True:
56
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1681
                p = self.changelog.parents(n)
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1682
                if p[1] != nullid or p[0] == nullid:
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1683
                    b.append((t, n, p[0], p[1]))
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1684
                    break
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1685
                n = p[0]
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1686
        return b
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1687
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1688
    def between(self, pairs):
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1689
        r = []
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1690
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1691
        for top, bottom in pairs:
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1692
            n, l, i = top, [], 0
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1693
            f = 1
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1694
7708
a32847fa0df0 wire protocol: avoid infinite loop (issue1483)
Matt Mackall <mpm@selenic.com>
parents: 7564
diff changeset
  1695
            while n != bottom and n != nullid:
56
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1696
                p = self.changelog.parents(n)[0]
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1697
                if i == f:
575
7f5ce4bbdd7b More whitespace cleanups
mpm@selenic.com
parents: 566
diff changeset
  1698
                    l.append(n)
56
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1699
                    f = f * 2
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1700
                n = p
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1701
                i += 1
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1702
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1703
            r.append(l)
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1704
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1705
        return r
ad2ea1185f04 Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents: 55
diff changeset
  1706
4917
126f527b3ba3 Make repo locks recursive, eliminate all passing of lock/wlock
Matt Mackall <mpm@selenic.com>
parents: 4916
diff changeset
  1707
    def pull(self, remote, heads=None, force=False):
20469
6b4c789d618d exchange: extract pull function from localrepo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 20406
diff changeset
  1708
        return exchange.pull (self, remote, heads, force)
13364
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1709
20924
e10000369b47 push: pass a `pushoperation` object to localrepo.checkpush
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 20884
diff changeset
  1710
    def checkpush(self, pushop):
13327
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1711
        """Extensions can override this function if additional checks have
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1712
        to be performed before pushing, or call it if they override push
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1713
        command.
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1714
        """
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1715
        pass
dc11e30b48a3 mq: factor out push conditions checks
Patrick Mezard <pmezard@gmail.com>
parents: 13272
diff changeset
  1716
21043
6c383c871fdb localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20987
diff changeset
  1717
    @unfilteredpropertycache
6c383c871fdb localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20987
diff changeset
  1718
    def prepushoutgoinghooks(self):
6c383c871fdb localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20987
diff changeset
  1719
        """Return util.hooks consists of "(repo, remote, outgoing)"
6c383c871fdb localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20987
diff changeset
  1720
        functions, which are called before pushing changesets.
6c383c871fdb localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20987
diff changeset
  1721
        """
6c383c871fdb localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20987
diff changeset
  1722
        return util.hooks()
6c383c871fdb localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20987
diff changeset
  1723
11211
e43c23d189a5 push: add --new-branch option to allow intial push of new branches
Sune Foldager <cryo@cyanite.org>
parents: 11177
diff changeset
  1724
    def push(self, remote, force=False, revs=None, newbranch=False):
20345
8567b4ea76ac exchange: extract push function from localrepo
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 20332
diff changeset
  1725
        return exchange.push(self, remote, force, revs, newbranch)
13364
ddddb76f2da3 bookmarks: merge low-level push/pull support into core
Matt Mackall <mpm@selenic.com>
parents: 13363
diff changeset
  1726
12296
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  1727
    def stream_in(self, remote, requirements):
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1728
        lock = self.lock()
3564
eda9e7c9300d New UnexpectedOutput exception to catch server errors in localrepo.stream_in
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3513
diff changeset
  1729
        try:
17740
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  1730
            # Save remote branchmap. We will use it later
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  1731
            # to speed up branchcache creation
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  1732
            rbranchmap = None
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  1733
            if remote.capable("branchmap"):
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  1734
                rbranchmap = remote.branchmap()
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  1735
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1736
            fp = remote.stream_out()
3564
eda9e7c9300d New UnexpectedOutput exception to catch server errors in localrepo.stream_in
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3513
diff changeset
  1737
            l = fp.readline()
eda9e7c9300d New UnexpectedOutput exception to catch server errors in localrepo.stream_in
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3513
diff changeset
  1738
            try:
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1739
                resp = int(l)
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1740
            except ValueError:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1741
                raise error.ResponseError(
16941
a1eb17bed550 localrepo: lowercase "unexpected response" message
Martin Geisler <mg@aragost.com>
parents: 16866
diff changeset
  1742
                    _('unexpected response from remote server:'), l)
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1743
            if resp == 1:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1744
                raise util.Abort(_('operation forbidden by server'))
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1745
            elif resp == 2:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1746
                raise util.Abort(_('locking the remote repository failed'))
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1747
            elif resp != 0:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1748
                raise util.Abort(_('the server sent an unknown error code'))
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1749
            self.ui.status(_('streaming all changes\n'))
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1750
            l = fp.readline()
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1751
            try:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1752
                total_files, total_bytes = map(int, l.split(' ', 1))
7063
be2daa324ddf Add missing catch of a TypeError
Bernhard Leiner <bleiner@gmail.com>
parents: 6877
diff changeset
  1753
            except (ValueError, TypeError):
7641
d2f753830f80 error: move UnexpectedOutput (now ResponseError)
Matt Mackall <mpm@selenic.com>
parents: 7640
diff changeset
  1754
                raise error.ResponseError(
16941
a1eb17bed550 localrepo: lowercase "unexpected response" message
Martin Geisler <mg@aragost.com>
parents: 16866
diff changeset
  1755
                    _('unexpected response from remote server:'), l)
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1756
            self.ui.status(_('%d files to transfer, %s of data\n') %
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1757
                           (total_files, util.bytecount(total_bytes)))
16770
b3435385f99f clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents: 16745
diff changeset
  1758
            handled_bytes = 0
b3435385f99f clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents: 16745
diff changeset
  1759
            self.ui.progress(_('clone'), 0, total=total_bytes)
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1760
            start = time.time()
20880
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1761
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1762
            tr = self.transaction(_('clone'))
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1763
            try:
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1764
                for i in xrange(total_files):
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1765
                    # XXX doesn't support '\n' or '\r' in filenames
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1766
                    l = fp.readline()
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1767
                    try:
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1768
                        name, size = l.split('\0', 1)
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1769
                        size = int(size)
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1770
                    except (ValueError, TypeError):
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1771
                        raise error.ResponseError(
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1772
                            _('unexpected response from remote server:'), l)
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1773
                    if self.ui.debugflag:
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1774
                        self.ui.debug('adding %s (%s)\n' %
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1775
                                      (name, util.bytecount(size)))
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1776
                    # for backwards compat, name was partially encoded
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1777
                    ofp = self.sopener(store.decodedir(name), 'w')
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1778
                    for chunk in util.filechunkiter(fp, limit=size):
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1779
                        handled_bytes += len(chunk)
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1780
                        self.ui.progress(_('clone'), handled_bytes,
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1781
                                         total=total_bytes)
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1782
                        ofp.write(chunk)
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1783
                    ofp.close()
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1784
                tr.close()
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1785
            finally:
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1786
                tr.release()
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1787
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1788
            # Writing straight to files circumvented the inmemory caches
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1789
            self.invalidate()
925c2d604389 clone: put streaming clones in a transaction
Durham Goode <durham@fb.com>
parents: 20827
diff changeset
  1790
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1791
            elapsed = time.time() - start
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1792
            if elapsed <= 0:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1793
                elapsed = 0.001
16770
b3435385f99f clone: add progress calls to uncompressed code path
Augie Fackler <raf@durin42.com>
parents: 16745
diff changeset
  1794
            self.ui.progress(_('clone'), None)
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1795
            self.ui.status(_('transferred %s in %.1f seconds (%s/sec)\n') %
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1796
                           (util.bytecount(total_bytes), elapsed,
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1797
                            util.bytecount(total_bytes / elapsed)))
12296
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  1798
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1799
            # new requirements = old non-format requirements +
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16657
diff changeset
  1800
            #                    new format-related
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1801
            # requirements from the streamed-in repository
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1802
            requirements.update(set(self.requirements) - self.supportedformats)
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1803
            self._applyrequirements(requirements)
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1804
            self._writerequirements()
12296
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  1805
17740
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  1806
            if rbranchmap:
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  1807
                rbheads = []
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  1808
                for bheads in rbranchmap.itervalues():
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  1809
                    rbheads.extend(bheads)
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  1810
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  1811
                if rbheads:
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  1812
                    rtiprev = max((int(self.changelog.rev(node))
e6067bec18da branchcache: fetch source branchcache during clone (issue3378)
Tomasz Kleczek <tomasz.kleczek@fb.com>
parents: 17716
diff changeset
  1813
                            for node in rbheads))
18125
ad194a8ab5c1 branchmap: add the tipnode (cache key) on the branchcache object
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18124
diff changeset
  1814
                    cache = branchmap.branchcache(rbranchmap,
18126
090ada0acddb branchmap: add the tiprev (cache key) on the branchmap object
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18125
diff changeset
  1815
                                                  self[rtiprev].node(),
090ada0acddb branchmap: add the tiprev (cache key) on the branchmap object
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18125
diff changeset
  1816
                                                  rtiprev)
18397
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  1817
                    # Try to stick it as low as possible
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  1818
                    # filter above served are unlikely to be fetch from a clone
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  1819
                    for candidate in ('base', 'immutable', 'served'):
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  1820
                        rview = self.filtered(candidate)
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  1821
                        if cache.validfor(rview):
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  1822
                            self._branchcaches[candidate] = cache
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  1823
                            cache.write(rview)
ecf4f79cc600 stream_in: write the remote branchcache for a usage as wide as possible
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 18396
diff changeset
  1824
                            break
13390
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1825
            self.invalidate()
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1826
            return len(self.heads()) + 1
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1827
        finally:
327719a44b6a localrepo: acquire lock on stream_in
Adrian Buehlmann <adrian@cadifra.com>
parents: 13385
diff changeset
  1828
            lock.release()
515
03f27b1381f9 Whitespace cleanups
mpm@selenic.com
parents: 514
diff changeset
  1829
2613
479e26afa10f clone: do not make streaming default. add --stream option instead.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2612
diff changeset
  1830
    def clone(self, remote, heads=[], stream=False):
2612
ffb895f16925 add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2601
diff changeset
  1831
        '''clone remote repository.
1382
b113e7db06e9 hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents: 1375
diff changeset
  1832
2612
ffb895f16925 add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2601
diff changeset
  1833
        keyword arguments:
ffb895f16925 add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2601
diff changeset
  1834
        heads: list of revs to clone (forces use of pull)
2621
5a5852a417b1 clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2613
diff changeset
  1835
        stream: use streaming clone if possible'''
247
863b508c5b36 migrate verify
mpm@selenic.com
parents: 244
diff changeset
  1836
2621
5a5852a417b1 clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2613
diff changeset
  1837
        # now, all clients that can request uncompressed clones can
5a5852a417b1 clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2613
diff changeset
  1838
        # read repo formats supported by all servers that can serve
5a5852a417b1 clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2613
diff changeset
  1839
        # them.
247
863b508c5b36 migrate verify
mpm@selenic.com
parents: 244
diff changeset
  1840
2612
ffb895f16925 add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2601
diff changeset
  1841
        # if revlog format changes, client will have to check version
2621
5a5852a417b1 clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2613
diff changeset
  1842
        # and format flags on "stream" capability, and use
5a5852a417b1 clone: disable stream support on server side by default.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2613
diff changeset
  1843
        # uncompressed only if compatible.
247
863b508c5b36 migrate verify
mpm@selenic.com
parents: 244
diff changeset
  1844
16361
6097ede2be4d protocol: Add the stream-preferred capability
Benoit Allard <benoit@aeteurope.nl>
parents: 16253
diff changeset
  1845
        if not stream:
17427
57c6c24b9bc4 improve some comments and docstrings, fixing issues found when spell checking
Mads Kiilerich <mads@kiilerich.com>
parents: 17424
diff changeset
  1846
            # if the server explicitly prefers to stream (for fast LANs)
16361
6097ede2be4d protocol: Add the stream-preferred capability
Benoit Allard <benoit@aeteurope.nl>
parents: 16253
diff changeset
  1847
            stream = remote.capable('stream-preferred')
6097ede2be4d protocol: Add the stream-preferred capability
Benoit Allard <benoit@aeteurope.nl>
parents: 16253
diff changeset
  1848
12296
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  1849
        if stream and not heads:
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  1850
            # 'stream' means remote revlog format is revlogv1 only
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  1851
            if remote.capable('stream'):
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  1852
                return self.stream_in(remote, set(('revlogv1',)))
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  1853
            # otherwise, 'streamreqs' contains the remote revlog format
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  1854
            streamreqs = remote.capable('streamreqs')
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  1855
            if streamreqs:
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  1856
                streamreqs = set(streamreqs.split(','))
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  1857
                # if we support it, stream in and adjust our requirements
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  1858
                if not streamreqs - self.supportedformats:
d7fff529d85d clone: only use stream when we understand the revlog format
Sune Foldager <cryo@cyanite.org>
parents: 12295
diff changeset
  1859
                    return self.stream_in(remote, streamreqs)
2612
ffb895f16925 add support for streaming clone.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2601
diff changeset
  1860
        return self.pull(remote, heads)
1806
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
  1861
11368
b9eb005c54ad pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents: 11303
diff changeset
  1862
    def pushkey(self, namespace, key, old, new):
14102
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  1863
        self.hook('prepushkey', throw=True, namespace=namespace, key=key,
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  1864
                  old=old, new=new)
17293
d3f84ccc5495 pushkey: add more verbose debug output regarding pushkey
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17252
diff changeset
  1865
        self.ui.debug('pushing key for "%s:%s"\n' % (namespace, key))
14102
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  1866
        ret = pushkey.push(self, namespace, key, old, new)
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  1867
        self.hook('pushkey', namespace=namespace, key=key, old=old, new=new,
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  1868
                  ret=ret)
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  1869
        return ret
11368
b9eb005c54ad pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents: 11303
diff changeset
  1870
b9eb005c54ad pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents: 11303
diff changeset
  1871
    def listkeys(self, namespace):
14102
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  1872
        self.hook('prelistkeys', throw=True, namespace=namespace)
17293
d3f84ccc5495 pushkey: add more verbose debug output regarding pushkey
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17252
diff changeset
  1873
        self.ui.debug('listing keys for "%s"\n' % namespace)
14102
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  1874
        values = pushkey.list(self, namespace)
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  1875
        self.hook('listkeys', namespace=namespace, values=values)
7f45b1911893 pushkey: add hooks for pushkey/listkeys
Brodie Rao <brodie@bitheap.org>
parents: 14076
diff changeset
  1876
        return values
11368
b9eb005c54ad pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents: 11303
diff changeset
  1877
14048
58e58406ed19 wireproto: add test for new optional arg missing on server
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14036
diff changeset
  1878
    def debugwireargs(self, one, two, three=None, four=None, five=None):
13720
9c4e04fe267e debug: add debugwireargs to test argument passing over the wire
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 13716
diff changeset
  1879
        '''used to test argument passing over the wire'''
14048
58e58406ed19 wireproto: add test for new optional arg missing on server
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents: 14036
diff changeset
  1880
        return "%s %s %s %s %s" % (one, two, three, four, five)
11368
b9eb005c54ad pushkey: add localrepo support
Matt Mackall <mpm@selenic.com>
parents: 11303
diff changeset
  1881
14529
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  1882
    def savecommitmessage(self, text):
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  1883
        fp = self.opener('last-message.txt', 'wb')
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  1884
        try:
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  1885
            fp.write(text)
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  1886
        finally:
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  1887
            fp.close()
18054
b35e3364f94a check-code: there must also be whitespace between ')' and operator
Mads Kiilerich <madski@unity3d.com>
parents: 18044
diff changeset
  1888
        return self.pathto(fp.name[len(self.root) + 1:])
14529
e7a1814854b9 localrepo: add savecommitmessage() to write last-message.txt
Patrick Mezard <pmezard@gmail.com>
parents: 14522
diff changeset
  1889
1806
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
  1890
# used to avoid circular references so destructors work
3790
f183c18568df localrepo: change aftertrans to be independant of the store path
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3773
diff changeset
  1891
def aftertrans(files):
f183c18568df localrepo: change aftertrans to be independant of the store path
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 3773
diff changeset
  1892
    renamefiles = [tuple(t) for t in files]
1806
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
  1893
    def a():
18952
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
  1894
        for vfs, src, dest in renamefiles:
16441
9dd10a574af2 localrepo: do not complain about missing journal files
Alain Leufroy <alain.leufroy@logilab.fr>
parents: 16426
diff changeset
  1895
            try:
18952
8086b530e2ac localrepo: use "vfs.rename()" instead of "util.rename()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 18951
diff changeset
  1896
                vfs.rename(src, dest)
16441
9dd10a574af2 localrepo: do not complain about missing journal files
Alain Leufroy <alain.leufroy@logilab.fr>
parents: 16426
diff changeset
  1897
            except OSError: # journal file does not yet exist
9dd10a574af2 localrepo: do not complain about missing journal files
Alain Leufroy <alain.leufroy@logilab.fr>
parents: 16426
diff changeset
  1898
                pass
1806
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
  1899
    return a
a2c69737e65e Automatic nesting into running transactions in the same repository.
mason@suse.com
parents: 1802
diff changeset
  1900
14266
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
  1901
def undoname(fn):
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
  1902
    base, name = os.path.split(fn)
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
  1903
    assert name.startswith('journal')
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
  1904
    return os.path.join(base, name.replace('journal', 'undo', 1))
89e7d35e0ef0 fix bookmarks rollback behavior
Alexander Solovyov <alexander@solovyov.net>
parents: 13957
diff changeset
  1905
2740
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
  1906
def instance(ui, path, create):
14825
de9eb6b1da4f util: rename the util.localpath that uses url to urllocalpath (issue2875)
Mads Kiilerich <mads@kiilerich.com>
parents: 14756
diff changeset
  1907
    return localrepository(ui, util.urllocalpath(path), create)
3223
53e843840349 Whitespace/Tab cleanup
Thomas Arendsen Hein <thomas@intevation.de>
parents: 3164
diff changeset
  1908
2740
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
  1909
def islocal(path):
386f04d6ecb3 clean up hg.py: move repo constructor code into each repo module
Vadim Gelfer <vadim.gelfer@gmail.com>
parents: 2673
diff changeset
  1910
    return True