← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

  • Committer: John Arbash Meinel
  • Date: 2008-10-04 14:10:13 UTC
  • mto: This revision was merged to the branch mainline in revision 3805.
  • Revision ID: john@arbash-meinel.com-20081004141013-yskxjlwtuy2k18ue
Playing around with expanding requests for btree index nodes into neighboring nodes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree_4.py
1
 
# Copyright (C) 2007-2011 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""WorkingTree4 format and implementation.
18
18
 
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
 
 
41
import bzrlib
34
42
from bzrlib import (
35
43
    bzrdir,
36
44
    cache_utf8,
37
 
    config,
38
45
    conflicts as _mod_conflicts,
39
46
    debug,
 
47
    delta,
40
48
    dirstate,
41
49
    errors,
42
 
    filters as _mod_filters,
43
50
    generate_ids,
 
51
    globbing,
 
52
    ignores,
 
53
    merge,
44
54
    osutils,
45
55
    revision as _mod_revision,
46
56
    revisiontree,
 
57
    textui,
47
58
    trace,
48
59
    transform,
49
 
    views,
 
60
    urlutils,
 
61
    xml5,
 
62
    xml6,
50
63
    )
 
64
import bzrlib.branch
 
65
from bzrlib.transport import get_transport
 
66
import bzrlib.ui
51
67
""")
52
68
 
 
69
from bzrlib import symbol_versioning
53
70
from bzrlib.decorators import needs_read_lock, needs_write_lock
54
 
from bzrlib.inventory import Inventory, ROOT_ID, entry_factory
55
 
from bzrlib.lock import LogicalLockResult
56
 
from bzrlib.lockable_files import LockableFiles
 
71
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, entry_factory
 
72
from bzrlib.lockable_files import LockableFiles, TransportLock
57
73
from bzrlib.lockdir import LockDir
 
74
import bzrlib.mutabletree
58
75
from bzrlib.mutabletree import needs_tree_write_lock
59
76
from bzrlib.osutils import (
60
77
    file_kind,
61
78
    isdir,
 
79
    normpath,
62
80
    pathjoin,
 
81
    rand_chars,
63
82
    realpath,
64
83
    safe_unicode,
 
84
    splitpath,
65
85
    )
 
86
from bzrlib.trace import mutter, note
66
87
from bzrlib.transport.local import LocalTransport
67
 
from bzrlib.tree import (
68
 
    InterTree,
69
 
    InventoryTree,
70
 
    )
71
 
from bzrlib.workingtree import (
72
 
    InventoryWorkingTree,
73
 
    WorkingTree,
74
 
    WorkingTreeFormat,
75
 
    )
76
 
 
77
 
 
78
 
class DirStateWorkingTree(InventoryWorkingTree):
 
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
        )
 
97
from bzrlib.tree import Tree
 
98
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
 
99
 
 
100
 
 
101
class WorkingTree4(WorkingTree3):
 
102
    """This is the Format 4 working tree.
 
103
 
 
104
    This differs from WorkingTree3 by:
 
105
     - Having a consolidated internal dirstate, stored in a
 
106
       randomly-accessible sorted file on disk.
 
107
     - Not having a regular inventory attribute.  One can be synthesized 
 
108
       on demand but this is expensive and should be avoided.
 
109
 
 
110
    This is new in bzr 0.15.
 
111
    """
79
112
 
80
113
    def __init__(self, basedir,
81
114
                 branch,
92
125
        self._format = _format
93
126
        self.bzrdir = _bzrdir
94
127
        basedir = safe_unicode(basedir)
95
 
        trace.mutter("opening working tree %r", basedir)
 
128
        mutter("opening working tree %r", basedir)
96
129
        self._branch = branch
97
130
        self.basedir = realpath(basedir)
98
131
        # if branch is at our basedir and is a format 6 or less
109
142
        self._setup_directory_is_tree_reference()
110
143
        self._detect_case_handling()
111
144
        self._rules_searcher = None
112
 
        self.views = self._make_views()
113
145
        #--- allow tests to select the dirstate iter_changes implementation
114
146
        self._iter_changes = dirstate._process_entry
115
147
 
132
164
            state.add(f, file_id, kind, None, '')
133
165
        self._make_dirty(reset_inventory=True)
134
166
 
135
 
    def _get_check_refs(self):
136
 
        """Return the references needed to perform a check of this tree."""
137
 
        return [('trees', self.last_revision())]
138
 
 
139
167
    def _make_dirty(self, reset_inventory):
140
168
        """Make the tree state dirty.
141
169
 
149
177
    @needs_tree_write_lock
150
178
    def add_reference(self, sub_tree):
151
179
        # use standard implementation, which calls back to self._add
152
 
        #
 
180
        # 
153
181
        # So we don't store the reference_revision in the working dirstate,
154
 
        # it's just recorded at the moment of commit.
 
182
        # it's just recorded at the moment of commit. 
155
183
        self._add_reference(sub_tree)
156
184
 
157
185
    def break_lock(self):
193
221
 
194
222
    def _comparison_data(self, entry, path):
195
223
        kind, executable, stat_value = \
196
 
            WorkingTree._comparison_data(self, entry, path)
 
224
            WorkingTree3._comparison_data(self, entry, path)
197
225
        # it looks like a plain directory, but it's really a reference -- see
198
226
        # also kind()
199
 
        if (self._repo_supports_tree_reference and kind == 'directory'
200
 
            and entry is not None and entry.kind == 'tree-reference'):
 
227
        if (self._repo_supports_tree_reference and
 
228
            kind == 'directory' and
 
229
            self._directory_is_tree_reference(path)):
201
230
            kind = 'tree-reference'
202
231
        return kind, executable, stat_value
203
232
 
205
234
    def commit(self, message=None, revprops=None, *args, **kwargs):
206
235
        # mark the tree as dirty post commit - commit
207
236
        # can change the current versioned list by doing deletes.
208
 
        result = WorkingTree.commit(self, message, revprops, *args, **kwargs)
 
237
        result = WorkingTree3.commit(self, message, revprops, *args, **kwargs)
209
238
        self._make_dirty(reset_inventory=True)
210
239
        return result
211
240
 
229
258
            return self._dirstate
230
259
        local_path = self.bzrdir.get_workingtree_transport(None
231
260
            ).local_abspath('dirstate')
232
 
        self._dirstate = dirstate.DirState.on_file(local_path,
233
 
            self._sha1_provider(), self._worth_saving_limit())
 
261
        self._dirstate = dirstate.DirState.on_file(local_path)
234
262
        return self._dirstate
235
263
 
236
 
    def _sha1_provider(self):
237
 
        """A function that returns a SHA1Provider suitable for this tree.
238
 
 
239
 
        :return: None if content filtering is not supported by this tree.
240
 
          Otherwise, a SHA1Provider is returned that sha's the canonical
241
 
          form of files, i.e. after read filters are applied.
242
 
        """
243
 
        if self.supports_content_filtering():
244
 
            return ContentFilterAwareSHA1Provider(self)
245
 
        else:
246
 
            return None
247
 
 
248
 
    def _worth_saving_limit(self):
249
 
        """How many hash changes are ok before we must save the dirstate.
250
 
 
251
 
        :return: an integer. -1 means never save.
252
 
        """
253
 
        # FIXME: We want a WorkingTreeStack here -- vila 20110812
254
 
        conf = config.BranchStack(self.branch)
255
 
        return conf.get('bzr.workingtree.worth_saving_limit')
256
 
 
257
264
    def filter_unversioned_files(self, paths):
258
265
        """Filter out paths that are versioned.
259
266
 
291
298
 
292
299
    def _generate_inventory(self):
293
300
        """Create and set self.inventory from the dirstate object.
294
 
 
 
301
        
295
302
        This is relatively expensive: we have to walk the entire dirstate.
296
303
        Ideally we would not, and can deprecate this function.
297
304
        """
342
349
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
343
350
                elif kind == 'tree-reference':
344
351
                    if not self._repo_supports_tree_reference:
345
 
                        raise errors.UnsupportedOperation(
346
 
                            self._generate_inventory,
347
 
                            self.branch.repository)
 
352
                        raise AssertionError(
 
353
                            "repository of %r "
 
354
                            "doesn't support tree references "
 
355
                            "required by entry %r"
 
356
                            % (self, name))
348
357
                    inv_entry.reference_revision = link_or_sha1 or None
349
358
                elif kind != 'symlink':
350
359
                    raise AssertionError("unknown kind %r" % kind)
365
374
        If either file_id or path is supplied, it is used as the key to lookup.
366
375
        If both are supplied, the fastest lookup is used, and an error is
367
376
        raised if they do not both point at the same row.
368
 
 
 
377
        
369
378
        :param file_id: An optional unicode file_id to be looked up.
370
379
        :param path: An optional unicode path to be looked up.
371
380
        :return: The dirstate row tuple for path/file_id, or (None, None)
389
398
        state = self.current_dirstate()
390
399
        if stat_value is None:
391
400
            try:
392
 
                stat_value = osutils.lstat(file_abspath)
 
401
                stat_value = os.lstat(file_abspath)
393
402
            except OSError, e:
394
403
                if e.errno == errno.ENOENT:
395
404
                    return None
427
436
    @needs_read_lock
428
437
    def get_parent_ids(self):
429
438
        """See Tree.get_parent_ids.
430
 
 
 
439
        
431
440
        This implementation requests the ids list from the dirstate file.
432
441
        """
433
442
        return self.current_dirstate().get_parent_ids()
455
464
        return osutils.lexists(pathjoin(
456
465
                    self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
457
466
 
458
 
    def has_or_had_id(self, file_id):
459
 
        state = self.current_dirstate()
460
 
        row, parents = self._get_entry(file_id=file_id)
461
 
        return row is not None
462
 
 
463
467
    @needs_read_lock
464
468
    def id2path(self, file_id):
465
469
        "Convert a file-id to a path."
498
502
            self._must_be_locked()
499
503
            if not path:
500
504
                path = self.id2path(file_id)
501
 
            mode = osutils.lstat(self.abspath(path)).st_mode
 
505
            mode = os.lstat(self.abspath(path)).st_mode
502
506
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
503
507
 
504
508
    def all_file_ids(self):
571
575
    def _kind(self, relpath):
572
576
        abspath = self.abspath(relpath)
573
577
        kind = file_kind(abspath)
574
 
        if (self._repo_supports_tree_reference and kind == 'directory'):
575
 
            entry = self._get_entry(path=relpath)
576
 
            if entry[1] is not None:
577
 
                if entry[1][0][0] == 't':
578
 
                    kind = 'tree-reference'
 
578
        if (self._repo_supports_tree_reference and
 
579
            kind == 'directory' and
 
580
            self._directory_is_tree_reference(relpath)):
 
581
            kind = 'tree-reference'
579
582
        return kind
580
583
 
581
584
    @needs_read_lock
588
591
            return _mod_revision.NULL_REVISION
589
592
 
590
593
    def lock_read(self):
591
 
        """See Branch.lock_read, and WorkingTree.unlock.
592
 
 
593
 
        :return: A bzrlib.lock.LogicalLockResult.
594
 
        """
 
594
        """See Branch.lock_read, and WorkingTree.unlock."""
595
595
        self.branch.lock_read()
596
596
        try:
597
597
            self._control_files.lock_read()
610
610
        except:
611
611
            self.branch.unlock()
612
612
            raise
613
 
        return LogicalLockResult(self.unlock)
614
613
 
615
614
    def _lock_self_write(self):
616
615
        """This should be called after the branch is locked."""
631
630
        except:
632
631
            self.branch.unlock()
633
632
            raise
634
 
        return LogicalLockResult(self.unlock)
635
633
 
636
634
    def lock_tree_write(self):
637
 
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
638
 
 
639
 
        :return: A bzrlib.lock.LogicalLockResult.
640
 
        """
 
635
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
641
636
        self.branch.lock_read()
642
 
        return self._lock_self_write()
 
637
        self._lock_self_write()
643
638
 
644
639
    def lock_write(self):
645
 
        """See MutableTree.lock_write, and WorkingTree.unlock.
646
 
 
647
 
        :return: A bzrlib.lock.LogicalLockResult.
648
 
        """
 
640
        """See MutableTree.lock_write, and WorkingTree.unlock."""
649
641
        self.branch.lock_write()
650
 
        return self._lock_self_write()
 
642
        self._lock_self_write()
651
643
 
652
644
    @needs_tree_write_lock
653
645
    def move(self, from_paths, to_dir, after=False):
723
715
            from_entry = self._get_entry(path=from_rel)
724
716
            if from_entry == (None, None):
725
717
                raise errors.BzrMoveFailedError(from_rel,to_dir,
726
 
                    errors.NotVersionedError(path=from_rel))
 
718
                    errors.NotVersionedError(path=str(from_rel)))
727
719
 
728
720
            from_id = from_entry[0][2]
729
721
            to_rel = pathjoin(to_dir, from_tail)
870
862
                rollback_rename()
871
863
                raise
872
864
            result.append((from_rel, to_rel))
873
 
            state._mark_modified()
 
865
            state._dirblock_state = dirstate.DirState.IN_MEMORY_MODIFIED
874
866
            self._make_dirty(reset_inventory=False)
875
867
 
876
868
        return result
904
896
        for tree in trees:
905
897
            if not (isinstance(tree, DirStateRevisionTree) and tree._revision_id in
906
898
                parents):
907
 
                return super(DirStateWorkingTree, self).paths2ids(paths,
908
 
                    trees, require_versioned)
 
899
                return super(WorkingTree4, self).paths2ids(paths, trees, require_versioned)
909
900
        search_indexes = [0] + [1 + parents.index(tree._revision_id) for tree in trees]
910
901
        # -- make all paths utf8 --
911
902
        paths_utf8 = set()
972
963
                raise errors.PathsNotVersionedError(paths)
973
964
        # -- remove redundancy in supplied paths to prevent over-scanning --
974
965
        search_paths = osutils.minimum_path_selection(paths)
975
 
        # sketch:
 
966
        # sketch: 
976
967
        # for all search_indexs in each path at or under each element of
977
968
        # search_paths, if the detail is relocated: add the id, and add the
978
969
        # relocated path as one to search if its not searched already. If the
1034
1025
 
1035
1026
    def read_working_inventory(self):
1036
1027
        """Read the working inventory.
1037
 
 
 
1028
        
1038
1029
        This is a meaningless operation for dirstate, but we obey it anyhow.
1039
1030
        """
1040
1031
        return self.inventory
1058
1049
    def set_last_revision(self, new_revision):
1059
1050
        """Change the last revision in the working tree."""
1060
1051
        parents = self.get_parent_ids()
1061
 
        if new_revision in (_mod_revision.NULL_REVISION, None):
 
1052
        if new_revision in (NULL_REVISION, None):
1062
1053
            if len(parents) >= 2:
1063
1054
                raise AssertionError(
1064
1055
                    "setting the last parent to none with a pending merge is "
1071
1062
    @needs_tree_write_lock
1072
1063
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
1073
1064
        """Set the parent ids to revision_ids.
1074
 
 
 
1065
        
1075
1066
        See also set_parent_trees. This api will try to retrieve the tree data
1076
1067
        for each element of revision_ids from the trees repository. If you have
1077
1068
        tree data already available, it is more efficient to use
1133
1124
                        _mod_revision.NULL_REVISION)))
1134
1125
                ghosts.append(rev_id)
1135
1126
            accepted_revisions.add(rev_id)
1136
 
        updated = False
1137
 
        if (len(real_trees) == 1
1138
 
            and not ghosts
1139
 
            and self.branch.repository._format.fast_deltas
1140
 
            and isinstance(real_trees[0][1],
1141
 
                revisiontree.InventoryRevisionTree)
1142
 
            and self.get_parent_ids()):
1143
 
            rev_id, rev_tree = real_trees[0]
1144
 
            basis_id = self.get_parent_ids()[0]
1145
 
            # There are times when basis_tree won't be in
1146
 
            # self.branch.repository, (switch, for example)
1147
 
            try:
1148
 
                basis_tree = self.branch.repository.revision_tree(basis_id)
1149
 
            except errors.NoSuchRevision:
1150
 
                # Fall back to the set_parent_trees(), since we can't use
1151
 
                # _make_delta if we can't get the RevisionTree
1152
 
                pass
1153
 
            else:
1154
 
                delta = rev_tree.inventory._make_delta(basis_tree.inventory)
1155
 
                dirstate.update_basis_by_delta(delta, rev_id)
1156
 
                updated = True
1157
 
        if not updated:
1158
 
            dirstate.set_parent_trees(real_trees, ghosts=ghosts)
 
1127
        dirstate.set_parent_trees(real_trees, ghosts=ghosts)
1159
1128
        self._make_dirty(reset_inventory=False)
1160
1129
 
1161
1130
    def _set_root_id(self, file_id):
1181
1150
 
1182
1151
    def unlock(self):
1183
1152
        """Unlock in format 4 trees needs to write the entire dirstate."""
 
1153
        # do non-implementation specific cleanup
 
1154
        self._cleanup()
 
1155
 
1184
1156
        if self._control_files._lock_count == 1:
1185
 
            # do non-implementation specific cleanup
1186
 
            self._cleanup()
1187
 
 
1188
1157
            # eventually we should do signature checking during read locks for
1189
1158
            # dirstate updates.
1190
1159
            if self._control_files._lock_mode == 'w':
1253
1222
                # just forget the whole block.
1254
1223
                entry_index = 0
1255
1224
                while entry_index < len(block[1]):
 
1225
                    # Mark this file id as having been removed
1256
1226
                    entry = block[1][entry_index]
1257
 
                    if entry[1][0][0] in 'ar':
1258
 
                        # don't remove absent or renamed entries
 
1227
                    ids_to_unversion.discard(entry[0][2])
 
1228
                    if (entry[1][0][0] in 'ar' # don't remove absent or renamed
 
1229
                                               # entries
 
1230
                        or not state._make_absent(entry)):
1259
1231
                        entry_index += 1
1260
 
                    else:
1261
 
                        # Mark this file id as having been removed
1262
 
                        ids_to_unversion.discard(entry[0][2])
1263
 
                        if not state._make_absent(entry):
1264
 
                            # The block has not shrunk.
1265
 
                            entry_index += 1
1266
1232
                # go to the next block. (At the moment we dont delete empty
1267
1233
                # dirblocks)
1268
1234
                block_index += 1
1289
1255
        # have to change the legacy inventory too.
1290
1256
        if self._inventory is not None:
1291
1257
            for file_id in file_ids:
1292
 
                if self._inventory.has_id(file_id):
1293
 
                    self._inventory.remove_recursive_id(file_id)
 
1258
                self._inventory.remove_recursive_id(file_id)
1294
1259
 
1295
1260
    @needs_tree_write_lock
1296
1261
    def rename_one(self, from_rel, to_rel, after=False):
1297
1262
        """See WorkingTree.rename_one"""
1298
1263
        self.flush()
1299
 
        super(DirStateWorkingTree, self).rename_one(from_rel, to_rel, after)
 
1264
        WorkingTree.rename_one(self, from_rel, to_rel, after)
1300
1265
 
1301
1266
    @needs_tree_write_lock
1302
1267
    def apply_inventory_delta(self, changes):
1321
1286
        if self._dirty:
1322
1287
            raise AssertionError("attempting to write an inventory when the "
1323
1288
                "dirstate is dirty will lose pending changes")
1324
 
        had_inventory = self._inventory is not None
1325
 
        # Setting self._inventory = None forces the dirstate to regenerate the
1326
 
        # working inventory. We do this because self.inventory may be inv, or
1327
 
        # may have been modified, and either case would prevent a clean delta
1328
 
        # being created.
1329
 
        self._inventory = None
1330
 
        # generate a delta,
1331
 
        delta = inv._make_delta(self.inventory)
1332
 
        # and apply it.
1333
 
        self.apply_inventory_delta(delta)
1334
 
        if had_inventory:
 
1289
        self.current_dirstate().set_state_from_inventory(inv)
 
1290
        self._make_dirty(reset_inventory=False)
 
1291
        if self._inventory is not None:
1335
1292
            self._inventory = inv
1336
1293
        self.flush()
1337
1294
 
1338
 
    @needs_tree_write_lock
1339
 
    def reset_state(self, revision_ids=None):
1340
 
        """Reset the state of the working tree.
1341
 
 
1342
 
        This does a hard-reset to a last-known-good state. This is a way to
1343
 
        fix if something got corrupted (like the .bzr/checkout/dirstate file)
1344
 
        """
1345
 
        if revision_ids is None:
1346
 
            revision_ids = self.get_parent_ids()
1347
 
        if not revision_ids:
1348
 
            base_tree = self.branch.repository.revision_tree(
1349
 
                _mod_revision.NULL_REVISION)
1350
 
            trees = []
1351
 
        else:
1352
 
            trees = zip(revision_ids,
1353
 
                        self.branch.repository.revision_trees(revision_ids))
1354
 
            base_tree = trees[0][1]
1355
 
        state = self.current_dirstate()
1356
 
        # We don't support ghosts yet
1357
 
        state.set_state_from_scratch(base_tree.inventory, trees, [])
1358
 
 
1359
 
 
1360
 
class ContentFilterAwareSHA1Provider(dirstate.SHA1Provider):
1361
 
 
1362
 
    def __init__(self, tree):
1363
 
        self.tree = tree
1364
 
 
1365
 
    def sha1(self, abspath):
1366
 
        """See dirstate.SHA1Provider.sha1()."""
1367
 
        filters = self.tree._content_filter_stack(
1368
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1369
 
        return _mod_filters.internal_size_sha_file_byname(abspath, filters)[1]
1370
 
 
1371
 
    def stat_and_sha1(self, abspath):
1372
 
        """See dirstate.SHA1Provider.stat_and_sha1()."""
1373
 
        filters = self.tree._content_filter_stack(
1374
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1375
 
        file_obj = file(abspath, 'rb', 65000)
1376
 
        try:
1377
 
            statvalue = os.fstat(file_obj.fileno())
1378
 
            if filters:
1379
 
                file_obj = _mod_filters.filtered_input_file(file_obj, filters)
1380
 
            sha1 = osutils.size_sha_file(file_obj)[1]
1381
 
        finally:
1382
 
            file_obj.close()
1383
 
        return statvalue, sha1
1384
 
 
1385
 
 
1386
 
class ContentFilteringDirStateWorkingTree(DirStateWorkingTree):
1387
 
    """Dirstate working tree that supports content filtering.
1388
 
 
1389
 
    The dirstate holds the hash and size of the canonical form of the file, 
1390
 
    and most methods must return that.
1391
 
    """
1392
 
 
1393
 
    def _file_content_summary(self, path, stat_result):
1394
 
        # This is to support the somewhat obsolete path_content_summary method
1395
 
        # with content filtering: see
1396
 
        # <https://bugs.launchpad.net/bzr/+bug/415508>.
1397
 
        #
1398
 
        # If the dirstate cache is up to date and knows the hash and size,
1399
 
        # return that.
1400
 
        # Otherwise if there are no content filters, return the on-disk size
1401
 
        # and leave the hash blank.
1402
 
        # Otherwise, read and filter the on-disk file and use its size and
1403
 
        # hash.
1404
 
        #
1405
 
        # The dirstate doesn't store the size of the canonical form so we
1406
 
        # can't trust it for content-filtered trees.  We just return None.
1407
 
        dirstate_sha1 = self._dirstate.sha1_from_stat(path, stat_result)
1408
 
        executable = self._is_executable_from_path_and_stat(path, stat_result)
1409
 
        return ('file', None, executable, dirstate_sha1)
1410
 
 
1411
 
 
1412
 
class WorkingTree4(DirStateWorkingTree):
1413
 
    """This is the Format 4 working tree.
1414
 
 
1415
 
    This differs from WorkingTree by:
1416
 
     - Having a consolidated internal dirstate, stored in a
1417
 
       randomly-accessible sorted file on disk.
1418
 
     - Not having a regular inventory attribute.  One can be synthesized
1419
 
       on demand but this is expensive and should be avoided.
1420
 
 
1421
 
    This is new in bzr 0.15.
1422
 
    """
1423
 
 
1424
 
 
1425
 
class WorkingTree5(ContentFilteringDirStateWorkingTree):
1426
 
    """This is the Format 5 working tree.
1427
 
 
1428
 
    This differs from WorkingTree4 by:
1429
 
     - Supporting content filtering.
1430
 
 
1431
 
    This is new in bzr 1.11.
1432
 
    """
1433
 
 
1434
 
 
1435
 
class WorkingTree6(ContentFilteringDirStateWorkingTree):
1436
 
    """This is the Format 6 working tree.
1437
 
 
1438
 
    This differs from WorkingTree5 by:
1439
 
     - Supporting a current view that may mask the set of files in a tree
1440
 
       impacted by most user operations.
1441
 
 
1442
 
    This is new in bzr 1.14.
1443
 
    """
1444
 
 
1445
 
    def _make_views(self):
1446
 
        return views.PathBasedViews(self)
1447
 
 
1448
 
 
1449
 
class DirStateWorkingTreeFormat(WorkingTreeFormat):
1450
 
 
1451
 
    missing_parent_conflicts = True
1452
 
 
1453
 
    supports_versioned_directories = True
1454
 
 
1455
 
    _lock_class = LockDir
1456
 
    _lock_file_name = 'lock'
1457
 
 
1458
 
    def _open_control_files(self, a_bzrdir):
1459
 
        transport = a_bzrdir.get_workingtree_transport(None)
1460
 
        return LockableFiles(transport, self._lock_file_name,
1461
 
                             self._lock_class)
 
1295
 
 
1296
class WorkingTreeFormat4(WorkingTreeFormat3):
 
1297
    """The first consolidated dirstate working tree format.
 
1298
 
 
1299
    This format:
 
1300
        - exists within a metadir controlling .bzr
 
1301
        - includes an explicit version marker for the workingtree control
 
1302
          files, separate from the BzrDir format
 
1303
        - modifies the hash cache format
 
1304
        - is new in bzr 0.15
 
1305
        - uses a LockDir to guard access to it.
 
1306
    """
 
1307
 
 
1308
    upgrade_recommended = False
 
1309
 
 
1310
    _tree_class = WorkingTree4
 
1311
 
 
1312
    def get_format_string(self):
 
1313
        """See WorkingTreeFormat.get_format_string()."""
 
1314
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
 
1315
 
 
1316
    def get_format_description(self):
 
1317
        """See WorkingTreeFormat.get_format_description()."""
 
1318
        return "Working tree format 4"
1462
1319
 
1463
1320
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
1464
1321
                   accelerator_tree=None, hardlink=False):
1465
1322
        """See WorkingTreeFormat.initialize().
1466
1323
 
1467
1324
        :param revision_id: allows creating a working tree at a different
1468
 
            revision than the branch is at.
 
1325
        revision than the branch is at.
1469
1326
        :param accelerator_tree: A tree which can be used for retrieving file
1470
1327
            contents more quickly than the revision tree, i.e. a workingtree.
1471
1328
            The revision tree will be used for cases where accelerator_tree's
1504
1361
        wt.lock_tree_write()
1505
1362
        try:
1506
1363
            self._init_custom_control_files(wt)
1507
 
            if revision_id in (None, _mod_revision.NULL_REVISION):
 
1364
            if revision_id in (None, NULL_REVISION):
1508
1365
                if branch.repository.supports_rich_root():
1509
1366
                    wt._set_root_id(generate_ids.gen_root_id())
1510
1367
                else:
1521
1378
                    pass
1522
1379
            if basis is None:
1523
1380
                basis = branch.repository.revision_tree(revision_id)
1524
 
            if revision_id == _mod_revision.NULL_REVISION:
 
1381
            if revision_id == NULL_REVISION:
1525
1382
                parents_list = []
1526
1383
            else:
1527
1384
                parents_list = [(revision_id, basis)]
1535
1392
                if basis_root_id is not None:
1536
1393
                    wt._set_root_id(basis_root_id)
1537
1394
                    wt.flush()
1538
 
                if wt.supports_content_filtering():
1539
 
                    # The original tree may not have the same content filters
1540
 
                    # applied so we can't safely build the inventory delta from
1541
 
                    # the source tree.
1542
 
                    delta_from_tree = False
1543
 
                else:
1544
 
                    delta_from_tree = True
1545
1395
                # delta_from_tree is safe even for DirStateRevisionTrees,
1546
1396
                # because wt4.apply_inventory_delta does not mutate the input
1547
1397
                # inventory entries.
1548
1398
                transform.build_tree(basis, wt, accelerator_tree,
1549
 
                                     hardlink=hardlink,
1550
 
                                     delta_from_tree=delta_from_tree)
 
1399
                                     hardlink=hardlink, delta_from_tree=True)
1551
1400
            finally:
1552
1401
                basis.unlock()
1553
1402
        finally:
1557
1406
 
1558
1407
    def _init_custom_control_files(self, wt):
1559
1408
        """Subclasses with custom control files should override this method.
1560
 
 
 
1409
        
1561
1410
        The working tree and control files are locked for writing when this
1562
1411
        method is called.
1563
 
 
 
1412
        
1564
1413
        :param wt: the WorkingTree object
1565
1414
        """
1566
1415
 
1567
 
    def open(self, a_bzrdir, _found=False):
1568
 
        """Return the WorkingTree object for a_bzrdir
1569
 
 
1570
 
        _found is a private parameter, do not use it. It is used to indicate
1571
 
               if format probing has already been done.
1572
 
        """
1573
 
        if not _found:
1574
 
            # we are being called directly and must probe.
1575
 
            raise NotImplementedError
1576
 
        if not isinstance(a_bzrdir.transport, LocalTransport):
1577
 
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
1578
 
        wt = self._open(a_bzrdir, self._open_control_files(a_bzrdir))
1579
 
        return wt
1580
 
 
1581
1416
    def _open(self, a_bzrdir, control_files):
1582
1417
        """Open the tree itself.
1583
1418
 
1591
1426
                           _control_files=control_files)
1592
1427
 
1593
1428
    def __get_matchingbzrdir(self):
1594
 
        return self._get_matchingbzrdir()
1595
 
 
1596
 
    def _get_matchingbzrdir(self):
1597
 
        """Overrideable method to get a bzrdir for testing."""
1598
1429
        # please test against something that will let us do tree references
1599
1430
        return bzrdir.format_registry.make_bzrdir(
1600
1431
            'dirstate-with-subtree')
1602
1433
    _matchingbzrdir = property(__get_matchingbzrdir)
1603
1434
 
1604
1435
 
1605
 
class WorkingTreeFormat4(DirStateWorkingTreeFormat):
1606
 
    """The first consolidated dirstate working tree format.
1607
 
 
1608
 
    This format:
1609
 
        - exists within a metadir controlling .bzr
1610
 
        - includes an explicit version marker for the workingtree control
1611
 
          files, separate from the BzrDir format
1612
 
        - modifies the hash cache format
1613
 
        - is new in bzr 0.15
1614
 
        - uses a LockDir to guard access to it.
1615
 
    """
1616
 
 
1617
 
    upgrade_recommended = False
1618
 
 
1619
 
    _tree_class = WorkingTree4
1620
 
 
1621
 
    def get_format_string(self):
1622
 
        """See WorkingTreeFormat.get_format_string()."""
1623
 
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
1624
 
 
1625
 
    def get_format_description(self):
1626
 
        """See WorkingTreeFormat.get_format_description()."""
1627
 
        return "Working tree format 4"
1628
 
 
1629
 
 
1630
 
class WorkingTreeFormat5(DirStateWorkingTreeFormat):
1631
 
    """WorkingTree format supporting content filtering.
1632
 
    """
1633
 
 
1634
 
    upgrade_recommended = False
1635
 
 
1636
 
    _tree_class = WorkingTree5
1637
 
 
1638
 
    def get_format_string(self):
1639
 
        """See WorkingTreeFormat.get_format_string()."""
1640
 
        return "Bazaar Working Tree Format 5 (bzr 1.11)\n"
1641
 
 
1642
 
    def get_format_description(self):
1643
 
        """See WorkingTreeFormat.get_format_description()."""
1644
 
        return "Working tree format 5"
1645
 
 
1646
 
    def supports_content_filtering(self):
1647
 
        return True
1648
 
 
1649
 
 
1650
 
class WorkingTreeFormat6(DirStateWorkingTreeFormat):
1651
 
    """WorkingTree format supporting views.
1652
 
    """
1653
 
 
1654
 
    upgrade_recommended = False
1655
 
 
1656
 
    _tree_class = WorkingTree6
1657
 
 
1658
 
    def get_format_string(self):
1659
 
        """See WorkingTreeFormat.get_format_string()."""
1660
 
        return "Bazaar Working Tree Format 6 (bzr 1.14)\n"
1661
 
 
1662
 
    def get_format_description(self):
1663
 
        """See WorkingTreeFormat.get_format_description()."""
1664
 
        return "Working tree format 6"
1665
 
 
1666
 
    def _init_custom_control_files(self, wt):
1667
 
        """Subclasses with custom control files should override this method."""
1668
 
        wt._transport.put_bytes('views', '', mode=wt.bzrdir._get_file_mode())
1669
 
 
1670
 
    def supports_content_filtering(self):
1671
 
        return True
1672
 
 
1673
 
    def supports_views(self):
1674
 
        return True
1675
 
 
1676
 
 
1677
 
class DirStateRevisionTree(InventoryTree):
1678
 
    """A revision tree pulling the inventory from a dirstate.
1679
 
    
1680
 
    Note that this is one of the historical (ie revision) trees cached in the
1681
 
    dirstate for easy access, not the workingtree.
1682
 
    """
 
1436
class DirStateRevisionTree(Tree):
 
1437
    """A revision tree pulling the inventory from a dirstate."""
1683
1438
 
1684
1439
    def __init__(self, dirstate, revision_id, repository):
1685
1440
        self._dirstate = dirstate
1699
1454
    def annotate_iter(self, file_id,
1700
1455
                      default_revision=_mod_revision.CURRENT_REVISION):
1701
1456
        """See Tree.annotate_iter"""
1702
 
        text_key = (file_id, self.get_file_revision(file_id))
 
1457
        text_key = (file_id, self.inventory[file_id].revision)
1703
1458
        annotations = self._repository.texts.annotate(text_key)
1704
1459
        return [(key[-1], line) for (key, line) in annotations]
1705
1460
 
 
1461
    def _get_ancestors(self, default_revision):
 
1462
        return set(self._repository.get_ancestry(self._revision_id,
 
1463
                                                 topo_sorted=False))
1706
1464
    def _comparison_data(self, entry, path):
1707
1465
        """See Tree._comparison_data."""
1708
1466
        if entry is None:
1751
1509
        If either file_id or path is supplied, it is used as the key to lookup.
1752
1510
        If both are supplied, the fastest lookup is used, and an error is
1753
1511
        raised if they do not both point at the same row.
1754
 
 
 
1512
        
1755
1513
        :param file_id: An optional unicode file_id to be looked up.
1756
1514
        :param path: An optional unicode path to be looked up.
1757
1515
        :return: The dirstate row tuple for path/file_id, or (None, None)
1824
1582
                elif kind == 'directory':
1825
1583
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
1826
1584
                elif kind == 'symlink':
 
1585
                    inv_entry.executable = False
 
1586
                    inv_entry.text_size = None
1827
1587
                    inv_entry.symlink_target = utf8_decode(fingerprint)[0]
1828
1588
                elif kind == 'tree-reference':
1829
1589
                    inv_entry.reference_revision = fingerprint or None
1852
1612
            return None
1853
1613
        parent_index = self._get_parent_index()
1854
1614
        last_changed_revision = entry[1][parent_index][4]
1855
 
        try:
1856
 
            rev = self._repository.get_revision(last_changed_revision)
1857
 
        except errors.NoSuchRevision:
1858
 
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
1859
 
        return rev.timestamp
 
1615
        return self._repository.get_revision(last_changed_revision).timestamp
1860
1616
 
1861
1617
    def get_file_sha1(self, file_id, path=None, stat_value=None):
1862
1618
        entry = self._get_entry(file_id=file_id, path=path)
1866
1622
            return parent_details[1]
1867
1623
        return None
1868
1624
 
1869
 
    @needs_read_lock
1870
 
    def get_file_revision(self, file_id):
1871
 
        return self.inventory[file_id].revision
1872
 
 
1873
1625
    def get_file(self, file_id, path=None):
1874
1626
        return StringIO(self.get_file_text(file_id))
1875
1627
 
 
1628
    def get_file_lines(self, file_id):
 
1629
        return osutils.split_lines(self.get_file_text(file_id))
 
1630
 
1876
1631
    def get_file_size(self, file_id):
1877
1632
        """See Tree.get_file_size"""
1878
1633
        return self.inventory[file_id].text_size
1879
1634
 
1880
 
    def get_file_text(self, file_id, path=None):
1881
 
        _, content = list(self.iter_files_bytes([(file_id, None)]))[0]
1882
 
        return ''.join(content)
 
1635
    def get_file_text(self, file_id):
 
1636
        return list(self.iter_files_bytes([(file_id, None)]))[0][1]
1883
1637
 
1884
1638
    def get_reference_revision(self, file_id, path=None):
1885
1639
        return self.inventory[file_id].reference_revision
1898
1652
                                       identifier))
1899
1653
        return self._repository.iter_files_bytes(repo_desired_files)
1900
1654
 
1901
 
    def get_symlink_target(self, file_id, path=None):
 
1655
    def get_symlink_target(self, file_id):
1902
1656
        entry = self._get_entry(file_id=file_id)
1903
1657
        parent_index = self._get_parent_index()
1904
1658
        if entry[1][parent_index][0] != 'l':
1905
1659
            return None
1906
1660
        else:
1907
 
            target = entry[1][parent_index][1]
1908
 
            target = target.decode('utf8')
1909
 
            return target
 
1661
            # At present, none of the tree implementations supports non-ascii
 
1662
            # symlink targets. So we will just assume that the dirstate path is
 
1663
            # correct.
 
1664
            return entry[1][parent_index][1]
1910
1665
 
1911
1666
    def get_revision_id(self):
1912
1667
        """Return the revision id for this tree."""
1933
1688
        entry = self._get_entry(file_id=file_id)[1]
1934
1689
        if entry is None:
1935
1690
            raise errors.NoSuchId(tree=self, file_id=file_id)
1936
 
        parent_index = self._get_parent_index()
1937
 
        return dirstate.DirState._minikind_to_kind[entry[parent_index][0]]
 
1691
        return dirstate.DirState._minikind_to_kind[entry[1][0]]
1938
1692
 
1939
1693
    def stored_kind(self, file_id):
1940
1694
        """See Tree.stored_kind"""
1957
1711
    def is_executable(self, file_id, path=None):
1958
1712
        ie = self.inventory[file_id]
1959
1713
        if ie.kind != "file":
1960
 
            return False
 
1714
            return None
1961
1715
        return ie.executable
1962
1716
 
1963
 
    def is_locked(self):
1964
 
        return self._locked
1965
 
 
1966
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
1717
    def list_files(self, include_root=False):
1967
1718
        # We use a standard implementation, because DirStateRevisionTree is
1968
1719
        # dealing with one of the parents of the current state
1969
1720
        inv = self._get_inventory()
1970
 
        if from_dir is None:
1971
 
            from_dir_id = None
1972
 
        else:
1973
 
            from_dir_id = inv.path2id(from_dir)
1974
 
            if from_dir_id is None:
1975
 
                # Directory not versioned
1976
 
                return
1977
 
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
1978
 
        if inv.root is not None and not include_root and from_dir is None:
 
1721
        entries = inv.iter_entries()
 
1722
        if self.inventory.root is not None and not include_root:
1979
1723
            entries.next()
1980
1724
        for path, entry in entries:
1981
1725
            yield path, 'V', entry.kind, entry.file_id, entry
1982
1726
 
1983
1727
    def lock_read(self):
1984
 
        """Lock the tree for a set of operations.
1985
 
 
1986
 
        :return: A bzrlib.lock.LogicalLockResult.
1987
 
        """
 
1728
        """Lock the tree for a set of operations."""
1988
1729
        if not self._locked:
1989
1730
            self._repository.lock_read()
1990
1731
            if self._dirstate._lock_token is None:
1991
1732
                self._dirstate.lock_read()
1992
1733
                self._dirstate_locked = True
1993
1734
        self._locked += 1
1994
 
        return LogicalLockResult(self.unlock)
1995
1735
 
1996
1736
    def _must_be_locked(self):
1997
1737
        if not self._locked:
2024
1764
 
2025
1765
    def walkdirs(self, prefix=""):
2026
1766
        # TODO: jam 20070215 This is the lazy way by using the RevisionTree
2027
 
        # implementation based on an inventory.
 
1767
        # implementation based on an inventory.  
2028
1768
        # This should be cleaned up to use the much faster Dirstate code
2029
1769
        # So for now, we just build up the parent inventory, and extract
2030
1770
        # it the same way RevisionTree does.
2059
1799
 
2060
1800
class InterDirStateTree(InterTree):
2061
1801
    """Fast path optimiser for changes_from with dirstate trees.
2062
 
 
2063
 
    This is used only when both trees are in the dirstate working file, and
2064
 
    the source is any parent within the dirstate, and the destination is
 
1802
    
 
1803
    This is used only when both trees are in the dirstate working file, and 
 
1804
    the source is any parent within the dirstate, and the destination is 
2065
1805
    the current working tree of the same dirstate.
2066
1806
    """
2067
1807
    # this could be generalized to allow comparisons between any trees in the
2076
1816
    def make_source_parent_tree(source, target):
2077
1817
        """Change the source tree into a parent of the target."""
2078
1818
        revid = source.commit('record tree')
2079
 
        target.branch.fetch(source.branch, revid)
 
1819
        target.branch.repository.fetch(source.branch.repository, revid)
2080
1820
        target.set_parent_ids([revid])
2081
1821
        return target.basis_tree(), target
2082
1822
 
2087
1827
        return result
2088
1828
 
2089
1829
    @classmethod
2090
 
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source,
2091
 
                                                  target):
 
1830
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source, target):
2092
1831
        from bzrlib.tests.test__dirstate_helpers import \
2093
 
            compiled_dirstate_helpers_feature
2094
 
        test_case.requireFeature(compiled_dirstate_helpers_feature)
2095
 
        from bzrlib._dirstate_helpers_pyx import ProcessEntryC
 
1832
            CompiledDirstateHelpersFeature
 
1833
        if not CompiledDirstateHelpersFeature.available():
 
1834
            from bzrlib.tests import UnavailableFeature
 
1835
            raise UnavailableFeature(CompiledDirstateHelpersFeature)
 
1836
        from bzrlib._dirstate_helpers_c import ProcessEntryC
2096
1837
        result = klass.make_source_parent_tree(source, target)
2097
1838
        result[1]._iter_changes = ProcessEntryC
2098
1839
        return result
2128
1869
            output. An unversioned file is defined as one with (False, False)
2129
1870
            for the versioned pair.
2130
1871
        """
 
1872
        # NB: show_status depends on being able to pass in non-versioned files
 
1873
        # and report them as unknown
2131
1874
        # TODO: handle extra trees in the dirstate.
2132
1875
        if (extra_trees or specific_files == []):
2133
1876
            # we can't fast-path these cases (yet)
2136
1879
                require_versioned, want_unversioned=want_unversioned)
2137
1880
        parent_ids = self.target.get_parent_ids()
2138
1881
        if not (self.source._revision_id in parent_ids
2139
 
                or self.source._revision_id == _mod_revision.NULL_REVISION):
 
1882
                or self.source._revision_id == NULL_REVISION):
2140
1883
            raise AssertionError(
2141
1884
                "revision {%s} is not stored in {%s}, but %s "
2142
1885
                "can only be used for trees stored in the dirstate"
2143
1886
                % (self.source._revision_id, self.target, self.iter_changes))
2144
1887
        target_index = 0
2145
 
        if self.source._revision_id == _mod_revision.NULL_REVISION:
 
1888
        if self.source._revision_id == NULL_REVISION:
2146
1889
            source_index = None
2147
1890
            indices = (target_index,)
2148
1891
        else:
2163
1906
        else:
2164
1907
            specific_files = set([''])
2165
1908
        # -- specific_files is now a utf8 path set --
2166
 
 
 
1909
        search_specific_files = set()
2167
1910
        # -- get the state object and prepare it.
2168
1911
        state = self.target.current_dirstate()
2169
1912
        state._read_dirblocks_if_needed()
2170
1913
        if require_versioned:
2171
1914
            # -- check all supplied paths are versioned in a search tree. --
2172
 
            not_versioned = []
 
1915
            all_versioned = True
2173
1916
            for path in specific_files:
2174
1917
                path_entries = state._entries_for_path(path)
2175
1918
                if not path_entries:
2176
1919
                    # this specified path is not present at all: error
2177
 
                    not_versioned.append(path)
2178
 
                    continue
 
1920
                    all_versioned = False
 
1921
                    break
2179
1922
                found_versioned = False
2180
1923
                # for each id at this path
2181
1924
                for entry in path_entries:
2188
1931
                if not found_versioned:
2189
1932
                    # none of the indexes was not 'absent' at all ids for this
2190
1933
                    # path.
2191
 
                    not_versioned.append(path)
2192
 
            if len(not_versioned) > 0:
2193
 
                raise errors.PathsNotVersionedError(not_versioned)
 
1934
                    all_versioned = False
 
1935
                    break
 
1936
            if not all_versioned:
 
1937
                raise errors.PathsNotVersionedError(specific_files)
2194
1938
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
2195
 
        search_specific_files = osutils.minimum_path_selection(specific_files)
 
1939
        for path in specific_files:
 
1940
            other_specific_files = specific_files.difference(set([path]))
 
1941
            if not osutils.is_inside_any(other_specific_files, path):
 
1942
                # this is a top level path, we must check it.
 
1943
                search_specific_files.add(path)
2196
1944
 
2197
1945
        use_filesystem_for_exec = (sys.platform != 'win32')
2198
1946
        iter_changes = self.target._iter_changes(include_unchanged,
2203
1951
    @staticmethod
2204
1952
    def is_compatible(source, target):
2205
1953
        # the target must be a dirstate working tree
2206
 
        if not isinstance(target, DirStateWorkingTree):
 
1954
        if not isinstance(target, WorkingTree4):
2207
1955
            return False
2208
 
        # the source must be a revtree or dirstate rev tree.
 
1956
        # the source must be a revtreee or dirstate rev tree.
2209
1957
        if not isinstance(source,
2210
1958
            (revisiontree.RevisionTree, DirStateRevisionTree)):
2211
1959
            return False
2212
1960
        # the source revid must be in the target dirstate
2213
 
        if not (source._revision_id == _mod_revision.NULL_REVISION or
 
1961
        if not (source._revision_id == NULL_REVISION or
2214
1962
            source._revision_id in target.get_parent_ids()):
2215
 
            # TODO: what about ghosts? it may well need to
 
1963
            # TODO: what about ghosts? it may well need to 
2216
1964
            # check for them explicitly.
2217
1965
            return False
2218
1966
        return True
2228
1976
 
2229
1977
    def convert(self, tree):
2230
1978
        # lock the control files not the tree, so that we dont get tree
2231
 
        # on-unlock behaviours, and so that noone else diddles with the
 
1979
        # on-unlock behaviours, and so that noone else diddles with the 
2232
1980
        # tree during upgrade.
2233
1981
        tree._control_files.lock_write()
2234
1982
        try:
2263
2011
        tree._transport.put_bytes('format',
2264
2012
            self.target_format.get_format_string(),
2265
2013
            mode=tree.bzrdir._get_file_mode())
2266
 
 
2267
 
 
2268
 
class Converter4to5(object):
2269
 
    """Perform an in-place upgrade of format 4 to format 5 trees."""
2270
 
 
2271
 
    def __init__(self):
2272
 
        self.target_format = WorkingTreeFormat5()
2273
 
 
2274
 
    def convert(self, tree):
2275
 
        # lock the control files not the tree, so that we don't get tree
2276
 
        # on-unlock behaviours, and so that no-one else diddles with the
2277
 
        # tree during upgrade.
2278
 
        tree._control_files.lock_write()
2279
 
        try:
2280
 
            self.update_format(tree)
2281
 
        finally:
2282
 
            tree._control_files.unlock()
2283
 
 
2284
 
    def update_format(self, tree):
2285
 
        """Change the format marker."""
2286
 
        tree._transport.put_bytes('format',
2287
 
            self.target_format.get_format_string(),
2288
 
            mode=tree.bzrdir._get_file_mode())
2289
 
 
2290
 
 
2291
 
class Converter4or5to6(object):
2292
 
    """Perform an in-place upgrade of format 4 or 5 to format 6 trees."""
2293
 
 
2294
 
    def __init__(self):
2295
 
        self.target_format = WorkingTreeFormat6()
2296
 
 
2297
 
    def convert(self, tree):
2298
 
        # lock the control files not the tree, so that we don't get tree
2299
 
        # on-unlock behaviours, and so that no-one else diddles with the
2300
 
        # tree during upgrade.
2301
 
        tree._control_files.lock_write()
2302
 
        try:
2303
 
            self.init_custom_control_files(tree)
2304
 
            self.update_format(tree)
2305
 
        finally:
2306
 
            tree._control_files.unlock()
2307
 
 
2308
 
    def init_custom_control_files(self, tree):
2309
 
        """Initialize custom control files."""
2310
 
        tree._transport.put_bytes('views', '',
2311
 
            mode=tree.bzrdir._get_file_mode())
2312
 
 
2313
 
    def update_format(self, tree):
2314
 
        """Change the format marker."""
2315
 
        tree._transport.put_bytes('format',
2316
 
            self.target_format.get_format_string(),
2317
 
            mode=tree.bzrdir._get_file_mode())