/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

(igc) Improve paths are not versioned reporting (Benoît PIERRE)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree_4.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
28
28
 
29
29
from bzrlib.lazy_import import lazy_import
30
30
lazy_import(globals(), """
 
31
from bisect import bisect_left
 
32
import collections
 
33
from copy import deepcopy
31
34
import errno
 
35
import itertools
 
36
import operator
32
37
import stat
 
38
from time import time
 
39
import warnings
33
40
 
34
41
import bzrlib
35
42
from bzrlib import (
36
43
    bzrdir,
37
44
    cache_utf8,
 
45
    conflicts as _mod_conflicts,
38
46
    debug,
 
47
    delta,
39
48
    dirstate,
40
49
    errors,
41
50
    generate_ids,
 
51
    globbing,
 
52
    ignores,
 
53
    merge,
42
54
    osutils,
43
55
    revision as _mod_revision,
44
56
    revisiontree,
 
57
    textui,
45
58
    trace,
46
59
    transform,
 
60
    urlutils,
47
61
    views,
 
62
    xml5,
 
63
    xml6,
48
64
    )
49
65
import bzrlib.branch
 
66
from bzrlib.transport import get_transport
50
67
import bzrlib.ui
51
68
""")
52
69
 
 
70
from bzrlib import symbol_versioning
53
71
from bzrlib.decorators import needs_read_lock, needs_write_lock
54
72
from bzrlib.filters import filtered_input_file, internal_size_sha_file_byname
55
 
from bzrlib.inventory import Inventory, ROOT_ID, entry_factory
 
73
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, entry_factory
 
74
import bzrlib.mutabletree
56
75
from bzrlib.mutabletree import needs_tree_write_lock
57
76
from bzrlib.osutils import (
58
77
    file_kind,
59
78
    isdir,
 
79
    normpath,
60
80
    pathjoin,
 
81
    rand_chars,
61
82
    realpath,
62
83
    safe_unicode,
 
84
    splitpath,
63
85
    )
64
 
from bzrlib.trace import mutter
 
86
from bzrlib.trace import mutter, note
65
87
from bzrlib.transport.local import LocalTransport
66
88
from bzrlib.tree import InterTree
 
89
from bzrlib.progress import DummyProgress, ProgressPhase
 
90
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
 
91
from bzrlib.rio import RioReader, rio_file, Stanza
 
92
from bzrlib.symbol_versioning import (deprecated_passed,
 
93
        deprecated_method,
 
94
        deprecated_function,
 
95
        DEPRECATED_PARAMETER,
 
96
        )
67
97
from bzrlib.tree import Tree
68
98
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
69
99
 
434
464
        return osutils.lexists(pathjoin(
435
465
                    self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
436
466
 
437
 
    def has_or_had_id(self, file_id):
438
 
        state = self.current_dirstate()
439
 
        row, parents = self._get_entry(file_id=file_id)
440
 
        return row is not None
441
 
 
442
467
    @needs_read_lock
443
468
    def id2path(self, file_id):
444
469
        "Convert a file-id to a path."
691
716
            from_entry = self._get_entry(path=from_rel)
692
717
            if from_entry == (None, None):
693
718
                raise errors.BzrMoveFailedError(from_rel,to_dir,
694
 
                    errors.NotVersionedError(path=from_rel))
 
719
                    errors.NotVersionedError(path=str(from_rel)))
695
720
 
696
721
            from_id = from_entry[0][2]
697
722
            to_rel = pathjoin(to_dir, from_tail)
1026
1051
    def set_last_revision(self, new_revision):
1027
1052
        """Change the last revision in the working tree."""
1028
1053
        parents = self.get_parent_ids()
1029
 
        if new_revision in (_mod_revision.NULL_REVISION, None):
 
1054
        if new_revision in (NULL_REVISION, None):
1030
1055
            if len(parents) >= 2:
1031
1056
                raise AssertionError(
1032
1057
                    "setting the last parent to none with a pending merge is "
1199
1224
                # just forget the whole block.
1200
1225
                entry_index = 0
1201
1226
                while entry_index < len(block[1]):
 
1227
                    # Mark this file id as having been removed
1202
1228
                    entry = block[1][entry_index]
1203
 
                    if entry[1][0][0] in 'ar':
1204
 
                        # don't remove absent or renamed entries
 
1229
                    ids_to_unversion.discard(entry[0][2])
 
1230
                    if (entry[1][0][0] in 'ar' # don't remove absent or renamed
 
1231
                                               # entries
 
1232
                        or not state._make_absent(entry)):
1205
1233
                        entry_index += 1
1206
 
                    else:
1207
 
                        # Mark this file id as having been removed
1208
 
                        ids_to_unversion.discard(entry[0][2])
1209
 
                        if not state._make_absent(entry):
1210
 
                            # The block has not shrunk.
1211
 
                            entry_index += 1
1212
1234
                # go to the next block. (At the moment we dont delete empty
1213
1235
                # dirblocks)
1214
1236
                block_index += 1
1266
1288
        if self._dirty:
1267
1289
            raise AssertionError("attempting to write an inventory when the "
1268
1290
                "dirstate is dirty will lose pending changes")
1269
 
        had_inventory = self._inventory is not None
1270
 
        # Setting self._inventory = None forces the dirstate to regenerate the
1271
 
        # working inventory. We do this because self.inventory may be inv, or
1272
 
        # may have been modified, and either case would prevent a clean delta
1273
 
        # being created.
1274
 
        self._inventory = None
1275
 
        # generate a delta,
1276
 
        delta = inv._make_delta(self.inventory)
1277
 
        # and apply it.
1278
 
        self.apply_inventory_delta(delta)
1279
 
        if had_inventory:
 
1291
        self.current_dirstate().set_state_from_inventory(inv)
 
1292
        self._make_dirty(reset_inventory=False)
 
1293
        if self._inventory is not None:
1280
1294
            self._inventory = inv
1281
1295
        self.flush()
1282
1296
 
1307
1321
        return statvalue, sha1
1308
1322
 
1309
1323
 
1310
 
class ContentFilteringDirStateWorkingTree(DirStateWorkingTree):
1311
 
    """Dirstate working tree that supports content filtering.
1312
 
 
1313
 
    The dirstate holds the hash and size of the canonical form of the file, 
1314
 
    and most methods must return that.
1315
 
    """
1316
 
 
1317
 
    def _file_content_summary(self, path, stat_result):
1318
 
        # This is to support the somewhat obsolete path_content_summary method
1319
 
        # with content filtering: see
1320
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/415508>.
1321
 
        #
1322
 
        # If the dirstate cache is up to date and knows the hash and size,
1323
 
        # return that.
1324
 
        # Otherwise if there are no content filters, return the on-disk size
1325
 
        # and leave the hash blank.
1326
 
        # Otherwise, read and filter the on-disk file and use its size and
1327
 
        # hash.
1328
 
        #
1329
 
        # The dirstate doesn't store the size of the canonical form so we
1330
 
        # can't trust it for content-filtered trees.  We just return None.
1331
 
        dirstate_sha1 = self._dirstate.sha1_from_stat(path, stat_result)
1332
 
        executable = self._is_executable_from_path_and_stat(path, stat_result)
1333
 
        return ('file', None, executable, dirstate_sha1)
1334
 
 
1335
 
 
1336
1324
class WorkingTree4(DirStateWorkingTree):
1337
1325
    """This is the Format 4 working tree.
1338
1326
 
1346
1334
    """
1347
1335
 
1348
1336
 
1349
 
class WorkingTree5(ContentFilteringDirStateWorkingTree):
 
1337
class WorkingTree5(DirStateWorkingTree):
1350
1338
    """This is the Format 5 working tree.
1351
1339
 
1352
1340
    This differs from WorkingTree4 by:
1356
1344
    """
1357
1345
 
1358
1346
 
1359
 
class WorkingTree6(ContentFilteringDirStateWorkingTree):
 
1347
class WorkingTree6(DirStateWorkingTree):
1360
1348
    """This is the Format 6 working tree.
1361
1349
 
1362
1350
    This differs from WorkingTree5 by:
1371
1359
 
1372
1360
 
1373
1361
class DirStateWorkingTreeFormat(WorkingTreeFormat3):
1374
 
 
1375
1362
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
1376
1363
                   accelerator_tree=None, hardlink=False):
1377
1364
        """See WorkingTreeFormat.initialize().
1416
1403
        wt.lock_tree_write()
1417
1404
        try:
1418
1405
            self._init_custom_control_files(wt)
1419
 
            if revision_id in (None, _mod_revision.NULL_REVISION):
 
1406
            if revision_id in (None, NULL_REVISION):
1420
1407
                if branch.repository.supports_rich_root():
1421
1408
                    wt._set_root_id(generate_ids.gen_root_id())
1422
1409
                else:
1433
1420
                    pass
1434
1421
            if basis is None:
1435
1422
                basis = branch.repository.revision_tree(revision_id)
1436
 
            if revision_id == _mod_revision.NULL_REVISION:
 
1423
            if revision_id == NULL_REVISION:
1437
1424
                parents_list = []
1438
1425
            else:
1439
1426
                parents_list = [(revision_id, basis)]
1447
1434
                if basis_root_id is not None:
1448
1435
                    wt._set_root_id(basis_root_id)
1449
1436
                    wt.flush()
 
1437
                # If content filtering is supported, do not use the accelerator
 
1438
                # tree - the cost of transforming the content both ways and
 
1439
                # checking for changed content can outweight the gains it gives.
 
1440
                # Note: do NOT move this logic up higher - using the basis from
 
1441
                # the accelerator tree is still desirable because that can save
 
1442
                # a minute or more of processing on large trees!
 
1443
                # The original tree may not have the same content filters
 
1444
                # applied so we can't safely build the inventory delta from
 
1445
                # the source tree.
1450
1446
                if wt.supports_content_filtering():
1451
 
                    # The original tree may not have the same content filters
1452
 
                    # applied so we can't safely build the inventory delta from
1453
 
                    # the source tree.
 
1447
                    accelerator_tree = None
1454
1448
                    delta_from_tree = False
1455
1449
                else:
1456
1450
                    delta_from_tree = True
1573
1567
 
1574
1568
 
1575
1569
class DirStateRevisionTree(Tree):
1576
 
    """A revision tree pulling the inventory from a dirstate.
1577
 
    
1578
 
    Note that this is one of the historical (ie revision) trees cached in the
1579
 
    dirstate for easy access, not the workingtree.
1580
 
    """
 
1570
    """A revision tree pulling the inventory from a dirstate."""
1581
1571
 
1582
1572
    def __init__(self, dirstate, revision_id, repository):
1583
1573
        self._dirstate = dirstate
1755
1745
            return None
1756
1746
        parent_index = self._get_parent_index()
1757
1747
        last_changed_revision = entry[1][parent_index][4]
1758
 
        try:
1759
 
            rev = self._repository.get_revision(last_changed_revision)
1760
 
        except errors.NoSuchRevision:
1761
 
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
1762
 
        return rev.timestamp
 
1748
        return self._repository.get_revision(last_changed_revision).timestamp
1763
1749
 
1764
1750
    def get_file_sha1(self, file_id, path=None, stat_value=None):
1765
1751
        entry = self._get_entry(file_id=file_id, path=path)
1832
1818
        entry = self._get_entry(file_id=file_id)[1]
1833
1819
        if entry is None:
1834
1820
            raise errors.NoSuchId(tree=self, file_id=file_id)
1835
 
        parent_index = self._get_parent_index()
1836
 
        return dirstate.DirState._minikind_to_kind[entry[parent_index][0]]
 
1821
        return dirstate.DirState._minikind_to_kind[entry[1][0]]
1837
1822
 
1838
1823
    def stored_kind(self, file_id):
1839
1824
        """See Tree.stored_kind"""
1979
1964
        return result
1980
1965
 
1981
1966
    @classmethod
1982
 
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source,
1983
 
                                                  target):
 
1967
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source, target):
1984
1968
        from bzrlib.tests.test__dirstate_helpers import \
1985
 
            compiled_dirstate_helpers_feature
1986
 
        test_case.requireFeature(compiled_dirstate_helpers_feature)
 
1969
            CompiledDirstateHelpersFeature
 
1970
        if not CompiledDirstateHelpersFeature.available():
 
1971
            from bzrlib.tests import UnavailableFeature
 
1972
            raise UnavailableFeature(CompiledDirstateHelpersFeature)
1987
1973
        from bzrlib._dirstate_helpers_pyx import ProcessEntryC
1988
1974
        result = klass.make_source_parent_tree(source, target)
1989
1975
        result[1]._iter_changes = ProcessEntryC
2020
2006
            output. An unversioned file is defined as one with (False, False)
2021
2007
            for the versioned pair.
2022
2008
        """
 
2009
        # NB: show_status depends on being able to pass in non-versioned files
 
2010
        # and report them as unknown
2023
2011
        # TODO: handle extra trees in the dirstate.
2024
2012
        if (extra_trees or specific_files == []):
2025
2013
            # we can't fast-path these cases (yet)
2028
2016
                require_versioned, want_unversioned=want_unversioned)
2029
2017
        parent_ids = self.target.get_parent_ids()
2030
2018
        if not (self.source._revision_id in parent_ids
2031
 
                or self.source._revision_id == _mod_revision.NULL_REVISION):
 
2019
                or self.source._revision_id == NULL_REVISION):
2032
2020
            raise AssertionError(
2033
2021
                "revision {%s} is not stored in {%s}, but %s "
2034
2022
                "can only be used for trees stored in the dirstate"
2035
2023
                % (self.source._revision_id, self.target, self.iter_changes))
2036
2024
        target_index = 0
2037
 
        if self.source._revision_id == _mod_revision.NULL_REVISION:
 
2025
        if self.source._revision_id == NULL_REVISION:
2038
2026
            source_index = None
2039
2027
            indices = (target_index,)
2040
2028
        else:
2102
2090
            (revisiontree.RevisionTree, DirStateRevisionTree)):
2103
2091
            return False
2104
2092
        # the source revid must be in the target dirstate
2105
 
        if not (source._revision_id == _mod_revision.NULL_REVISION or
 
2093
        if not (source._revision_id == NULL_REVISION or
2106
2094
            source._revision_id in target.get_parent_ids()):
2107
2095
            # TODO: what about ghosts? it may well need to
2108
2096
            # check for them explicitly.