← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

  • Committer: Martin Pool
  • Date: 2009-08-04 11:40:59 UTC
  • mfrom: (4584 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4586.
  • Revision ID: mbp@sourcefrog.net-20090804114059-xptutagbs5jev3ry
merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree_4.py
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
34
31
import errno
35
 
import itertools
36
 
import operator
37
32
import stat
38
 
from time import time
39
 
import warnings
40
33
 
41
34
import bzrlib
42
35
from bzrlib import (
43
36
    bzrdir,
44
37
    cache_utf8,
45
 
    conflicts as _mod_conflicts,
46
38
    debug,
47
 
    delta,
48
39
    dirstate,
49
40
    errors,
50
41
    generate_ids,
51
 
    globbing,
52
 
    ignores,
53
 
    merge,
54
42
    osutils,
55
43
    revision as _mod_revision,
56
44
    revisiontree,
57
 
    textui,
58
45
    trace,
59
46
    transform,
60
 
    urlutils,
61
47
    views,
62
 
    xml5,
63
 
    xml6,
64
48
    )
65
49
import bzrlib.branch
66
 
from bzrlib.transport import get_transport
67
50
import bzrlib.ui
68
51
""")
69
52
 
70
 
from bzrlib import symbol_versioning
71
53
from bzrlib.decorators import needs_read_lock, needs_write_lock
72
54
from bzrlib.filters import filtered_input_file, internal_size_sha_file_byname
73
 
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, entry_factory
 
55
from bzrlib.inventory import Inventory, ROOT_ID, entry_factory
74
56
import bzrlib.mutabletree
75
57
from bzrlib.mutabletree import needs_tree_write_lock
76
58
from bzrlib.osutils import (
77
59
    file_kind,
78
60
    isdir,
79
 
    normpath,
80
61
    pathjoin,
81
 
    rand_chars,
82
62
    realpath,
83
63
    safe_unicode,
84
 
    splitpath,
85
64
    )
86
 
from bzrlib.trace import mutter, note
 
65
from bzrlib.trace import mutter
87
66
from bzrlib.transport.local import LocalTransport
88
67
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
 
        )
97
68
from bzrlib.tree import Tree
98
69
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
99
70
 
464
435
        return osutils.lexists(pathjoin(
465
436
                    self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
466
437
 
 
438
    def has_or_had_id(self, file_id):
 
439
        state = self.current_dirstate()
 
440
        row, parents = self._get_entry(file_id=file_id)
 
441
        return row is not None
 
442
 
467
443
    @needs_read_lock
468
444
    def id2path(self, file_id):
469
445
        "Convert a file-id to a path."
716
692
            from_entry = self._get_entry(path=from_rel)
717
693
            if from_entry == (None, None):
718
694
                raise errors.BzrMoveFailedError(from_rel,to_dir,
719
 
                    errors.NotVersionedError(path=str(from_rel)))
 
695
                    errors.NotVersionedError(path=from_rel))
720
696
 
721
697
            from_id = from_entry[0][2]
722
698
            to_rel = pathjoin(to_dir, from_tail)
1051
1027
    def set_last_revision(self, new_revision):
1052
1028
        """Change the last revision in the working tree."""
1053
1029
        parents = self.get_parent_ids()
1054
 
        if new_revision in (NULL_REVISION, None):
 
1030
        if new_revision in (_mod_revision.NULL_REVISION, None):
1055
1031
            if len(parents) >= 2:
1056
1032
                raise AssertionError(
1057
1033
                    "setting the last parent to none with a pending merge is "
1224
1200
                # just forget the whole block.
1225
1201
                entry_index = 0
1226
1202
                while entry_index < len(block[1]):
1227
 
                    # Mark this file id as having been removed
1228
1203
                    entry = block[1][entry_index]
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)):
 
1204
                    if entry[1][0][0] in 'ar':
 
1205
                        # don't remove absent or renamed entries
1233
1206
                        entry_index += 1
 
1207
                    else:
 
1208
                        # Mark this file id as having been removed
 
1209
                        ids_to_unversion.discard(entry[0][2])
 
1210
                        if not state._make_absent(entry):
 
1211
                            # The block has not shrunk.
 
1212
                            entry_index += 1
1234
1213
                # go to the next block. (At the moment we dont delete empty
1235
1214
                # dirblocks)
1236
1215
                block_index += 1
1403
1382
        wt.lock_tree_write()
1404
1383
        try:
1405
1384
            self._init_custom_control_files(wt)
1406
 
            if revision_id in (None, NULL_REVISION):
 
1385
            if revision_id in (None, _mod_revision.NULL_REVISION):
1407
1386
                if branch.repository.supports_rich_root():
1408
1387
                    wt._set_root_id(generate_ids.gen_root_id())
1409
1388
                else:
1420
1399
                    pass
1421
1400
            if basis is None:
1422
1401
                basis = branch.repository.revision_tree(revision_id)
1423
 
            if revision_id == NULL_REVISION:
 
1402
            if revision_id == _mod_revision.NULL_REVISION:
1424
1403
                parents_list = []
1425
1404
            else:
1426
1405
                parents_list = [(revision_id, basis)]
1970
1949
        if not CompiledDirstateHelpersFeature.available():
1971
1950
            from bzrlib.tests import UnavailableFeature
1972
1951
            raise UnavailableFeature(CompiledDirstateHelpersFeature)
1973
 
        from bzrlib._dirstate_helpers_c import ProcessEntryC
 
1952
        from bzrlib._dirstate_helpers_pyx import ProcessEntryC
1974
1953
        result = klass.make_source_parent_tree(source, target)
1975
1954
        result[1]._iter_changes = ProcessEntryC
1976
1955
        return result
2016
1995
                require_versioned, want_unversioned=want_unversioned)
2017
1996
        parent_ids = self.target.get_parent_ids()
2018
1997
        if not (self.source._revision_id in parent_ids
2019
 
                or self.source._revision_id == NULL_REVISION):
 
1998
                or self.source._revision_id == _mod_revision.NULL_REVISION):
2020
1999
            raise AssertionError(
2021
2000
                "revision {%s} is not stored in {%s}, but %s "
2022
2001
                "can only be used for trees stored in the dirstate"
2023
2002
                % (self.source._revision_id, self.target, self.iter_changes))
2024
2003
        target_index = 0
2025
 
        if self.source._revision_id == NULL_REVISION:
 
2004
        if self.source._revision_id == _mod_revision.NULL_REVISION:
2026
2005
            source_index = None
2027
2006
            indices = (target_index,)
2028
2007
        else:
2049
2028
        state._read_dirblocks_if_needed()
2050
2029
        if require_versioned:
2051
2030
            # -- check all supplied paths are versioned in a search tree. --
2052
 
            all_versioned = True
 
2031
            not_versioned = []
2053
2032
            for path in specific_files:
2054
2033
                path_entries = state._entries_for_path(path)
2055
2034
                if not path_entries:
2056
2035
                    # this specified path is not present at all: error
2057
 
                    all_versioned = False
2058
 
                    break
 
2036
                    not_versioned.append(path)
 
2037
                    continue
2059
2038
                found_versioned = False
2060
2039
                # for each id at this path
2061
2040
                for entry in path_entries:
2068
2047
                if not found_versioned:
2069
2048
                    # none of the indexes was not 'absent' at all ids for this
2070
2049
                    # path.
2071
 
                    all_versioned = False
2072
 
                    break
2073
 
            if not all_versioned:
2074
 
                raise errors.PathsNotVersionedError(specific_files)
 
2050
                    not_versioned.append(path)
 
2051
            if len(not_versioned) > 0:
 
2052
                raise errors.PathsNotVersionedError(not_versioned)
2075
2053
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
2076
2054
        search_specific_files = osutils.minimum_path_selection(specific_files)
2077
2055
 
2091
2069
            (revisiontree.RevisionTree, DirStateRevisionTree)):
2092
2070
            return False
2093
2071
        # the source revid must be in the target dirstate
2094
 
        if not (source._revision_id == NULL_REVISION or
 
2072
        if not (source._revision_id == _mod_revision.NULL_REVISION or
2095
2073
            source._revision_id in target.get_parent_ids()):
2096
2074
            # TODO: what about ghosts? it may well need to
2097
2075
            # check for them explicitly.