← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-07-13 19:02:12 UTC
  • mfrom: (4986.2.8 deprecation)
  • Revision ID: pqm@pqm.ubuntu.com-20100713190212-bnayd5moplwtxhhb
(mbp) change some test tearDowns to addCleanup or overrideAttr (Martin Pool)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
29
29
WorkingTree.open(dir).
30
30
"""
31
31
 
32
 
# TODO: Give the workingtree sole responsibility for the working inventory;
33
 
# remove the variable and references to it from the branch.  This may require
34
 
# updating the commit code so as to update the inventory within the working
35
 
# copy, and making sure there's only one WorkingTree for any directory on disk.
36
 
# At the moment they may alias the inventory and have old copies of it in
37
 
# memory.  (Now done? -- mbp 20060309)
38
32
 
39
33
from cStringIO import StringIO
40
34
import os
48
42
import itertools
49
43
import operator
50
44
import stat
51
 
from time import time
52
 
import warnings
53
45
import re
54
46
 
55
47
import bzrlib
57
49
    branch,
58
50
    bzrdir,
59
51
    conflicts as _mod_conflicts,
60
 
    dirstate,
61
52
    errors,
62
53
    generate_ids,
63
54
    globbing,
 
55
    graph as _mod_graph,
64
56
    hashcache,
65
57
    ignores,
 
58
    inventory,
66
59
    merge,
67
60
    revision as _mod_revision,
68
61
    revisiontree,
69
 
    repository,
70
 
    textui,
71
62
    trace,
72
63
    transform,
 
64
    transport,
73
65
    ui,
74
 
    urlutils,
75
66
    views,
76
67
    xml5,
77
 
    xml6,
78
68
    xml7,
79
69
    )
80
 
import bzrlib.branch
81
 
from bzrlib.transport import get_transport
82
 
import bzrlib.ui
83
 
from bzrlib.workingtree_4 import WorkingTreeFormat4, WorkingTreeFormat5
 
70
from bzrlib.workingtree_4 import (
 
71
    WorkingTreeFormat4,
 
72
    WorkingTreeFormat5,
 
73
    WorkingTreeFormat6,
 
74
    )
84
75
""")
85
76
 
86
77
from bzrlib import symbol_versioning
87
78
from bzrlib.decorators import needs_read_lock, needs_write_lock
88
 
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, TreeReference
 
79
from bzrlib.lock import LogicalLockResult
89
80
from bzrlib.lockable_files import LockableFiles
90
81
from bzrlib.lockdir import LockDir
91
82
import bzrlib.mutabletree
92
83
from bzrlib.mutabletree import needs_tree_write_lock
93
84
from bzrlib import osutils
94
85
from bzrlib.osutils import (
95
 
    compact_date,
96
86
    file_kind,
97
87
    isdir,
98
88
    normpath,
99
89
    pathjoin,
100
 
    rand_chars,
101
90
    realpath,
102
91
    safe_unicode,
103
92
    splitpath,
106
95
from bzrlib.filters import filtered_input_file
107
96
from bzrlib.trace import mutter, note
108
97
from bzrlib.transport.local import LocalTransport
109
 
from bzrlib.progress import DummyProgress, ProgressPhase
110
 
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
 
98
from bzrlib.revision import CURRENT_REVISION
111
99
from bzrlib.rio import RioReader, rio_file, Stanza
112
 
from bzrlib.symbol_versioning import (deprecated_passed,
113
 
        deprecated_method,
114
 
        deprecated_function,
115
 
        DEPRECATED_PARAMETER,
116
 
        )
 
100
from bzrlib.symbol_versioning import (
 
101
    deprecated_passed,
 
102
    DEPRECATED_PARAMETER,
 
103
    )
117
104
 
118
105
 
119
106
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
 
107
# TODO: Modifying the conflict objects or their type is currently nearly
 
108
# impossible as there is no clear relationship between the working tree format
 
109
# and the conflict list file format.
120
110
CONFLICT_HEADER_1 = "BZR conflict list format 1"
121
111
 
122
112
ERROR_PATH_NOT_FOUND = 3    # WindowsError errno code, equivalent to ENOENT
177
167
        return ''
178
168
 
179
169
 
180
 
class WorkingTree(bzrlib.mutabletree.MutableTree):
 
170
class WorkingTree(bzrlib.mutabletree.MutableTree,
 
171
    bzrdir.ControlComponent):
181
172
    """Working copy tree.
182
173
 
183
174
    The inventory is held in the `Branch` working-inventory, and the
185
176
 
186
177
    It is possible for a `WorkingTree` to have a filename which is
187
178
    not listed in the Inventory and vice versa.
 
179
 
 
180
    :ivar basedir: The root of the tree on disk. This is a unicode path object
 
181
        (as opposed to a URL).
188
182
    """
189
183
 
190
184
    # override this to set the strategy for storing views
256
250
        self._rules_searcher = None
257
251
        self.views = self._make_views()
258
252
 
 
253
    @property
 
254
    def user_transport(self):
 
255
        return self.bzrdir.user_transport
 
256
 
 
257
    @property
 
258
    def control_transport(self):
 
259
        return self._transport
 
260
 
259
261
    def _detect_case_handling(self):
260
262
        wt_trans = self.bzrdir.get_workingtree_transport(None)
261
263
        try:
286
288
        self._control_files.break_lock()
287
289
        self.branch.break_lock()
288
290
 
 
291
    def _get_check_refs(self):
 
292
        """Return the references needed to perform a check of this tree.
 
293
        
 
294
        The default implementation returns no refs, and is only suitable for
 
295
        trees that have no local caching and can commit on ghosts at any time.
 
296
 
 
297
        :seealso: bzrlib.check for details about check_refs.
 
298
        """
 
299
        return []
 
300
 
289
301
    def requires_rich_root(self):
290
302
        return self._format.requires_rich_root
291
303
 
359
371
                return True, None
360
372
            else:
361
373
                return True, tree
362
 
        transport = get_transport(location)
363
 
        iterator = bzrdir.BzrDir.find_bzrdirs(transport, evaluate=evaluate,
 
374
        t = transport.get_transport(location)
 
375
        iterator = bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate,
364
376
                                              list_current=list_current)
365
 
        return [t for t in iterator if t is not None]
 
377
        return [tr for tr in iterator if tr is not None]
366
378
 
367
379
    # should be deprecated - this is slow and in any case treating them as a
368
380
    # container is (we now know) bad style -- mbp 20070302
415
427
            return self.branch.repository.revision_tree(revision_id)
416
428
        except (errors.RevisionNotPresent, errors.NoSuchRevision):
417
429
            # the basis tree *may* be a ghost or a low level error may have
418
 
            # occured. If the revision is present, its a problem, if its not
 
430
            # occurred. If the revision is present, its a problem, if its not
419
431
            # its a ghost.
420
432
            if self.branch.repository.has_revision(revision_id):
421
433
                raise
442
454
 
443
455
    def get_file_with_stat(self, file_id, path=None, filtered=True,
444
456
        _fstat=os.fstat):
445
 
        """See MutableTree.get_file_with_stat."""
 
457
        """See Tree.get_file_with_stat."""
446
458
        if path is None:
447
459
            path = self.id2path(file_id)
448
460
        file_obj = self.get_file_byname(path, filtered=False)
449
461
        stat_value = _fstat(file_obj.fileno())
450
 
        if self.supports_content_filtering() and filtered:
 
462
        if filtered and self.supports_content_filtering():
451
463
            filters = self._content_filter_stack(path)
452
464
            file_obj = filtered_input_file(file_obj, filters)
453
465
        return (file_obj, stat_value)
454
466
 
455
467
    def get_file_text(self, file_id, path=None, filtered=True):
456
 
        return self.get_file(file_id, path=path, filtered=filtered).read()
 
468
        my_file = self.get_file(file_id, path=path, filtered=filtered)
 
469
        try:
 
470
            return my_file.read()
 
471
        finally:
 
472
            my_file.close()
457
473
 
458
474
    def get_file_byname(self, filename, filtered=True):
459
475
        path = self.abspath(filename)
460
476
        f = file(path, 'rb')
461
 
        if self.supports_content_filtering() and filtered:
 
477
        if filtered and self.supports_content_filtering():
462
478
            filters = self._content_filter_stack(filename)
463
479
            return filtered_input_file(f, filters)
464
480
        else:
483
499
        incorrectly attributed to CURRENT_REVISION (but after committing, the
484
500
        attribution will be correct).
485
501
        """
486
 
        basis = self.basis_tree()
487
 
        basis.lock_read()
488
 
        try:
489
 
            changes = self.iter_changes(basis, True, [self.id2path(file_id)],
490
 
                require_versioned=True).next()
491
 
            changed_content, kind = changes[2], changes[6]
492
 
            if not changed_content:
493
 
                return basis.annotate_iter(file_id)
494
 
            if kind[1] is None:
495
 
                return None
496
 
            import annotate
497
 
            if kind[0] != 'file':
498
 
                old_lines = []
499
 
            else:
500
 
                old_lines = list(basis.annotate_iter(file_id))
501
 
            old = [old_lines]
502
 
            for tree in self.branch.repository.revision_trees(
503
 
                self.get_parent_ids()[1:]):
504
 
                if file_id not in tree:
505
 
                    continue
506
 
                old.append(list(tree.annotate_iter(file_id)))
507
 
            return annotate.reannotate(old, self.get_file(file_id).readlines(),
508
 
                                       default_revision)
509
 
        finally:
510
 
            basis.unlock()
 
502
        maybe_file_parent_keys = []
 
503
        for parent_id in self.get_parent_ids():
 
504
            try:
 
505
                parent_tree = self.revision_tree(parent_id)
 
506
            except errors.NoSuchRevisionInTree:
 
507
                parent_tree = self.branch.repository.revision_tree(parent_id)
 
508
            parent_tree.lock_read()
 
509
            try:
 
510
                if file_id not in parent_tree:
 
511
                    continue
 
512
                ie = parent_tree.inventory[file_id]
 
513
                if ie.kind != 'file':
 
514
                    # Note: this is slightly unnecessary, because symlinks and
 
515
                    # directories have a "text" which is the empty text, and we
 
516
                    # know that won't mess up annotations. But it seems cleaner
 
517
                    continue
 
518
                parent_text_key = (file_id, ie.revision)
 
519
                if parent_text_key not in maybe_file_parent_keys:
 
520
                    maybe_file_parent_keys.append(parent_text_key)
 
521
            finally:
 
522
                parent_tree.unlock()
 
523
        graph = _mod_graph.Graph(self.branch.repository.texts)
 
524
        heads = graph.heads(maybe_file_parent_keys)
 
525
        file_parent_keys = []
 
526
        for key in maybe_file_parent_keys:
 
527
            if key in heads:
 
528
                file_parent_keys.append(key)
 
529
 
 
530
        # Now we have the parents of this content
 
531
        annotator = self.branch.repository.texts.get_annotator()
 
532
        text = self.get_file_text(file_id)
 
533
        this_key =(file_id, default_revision)
 
534
        annotator.add_special_text(this_key, file_parent_keys, text)
 
535
        annotations = [(key[-1], line)
 
536
                       for key, line in annotator.annotate_flat(this_key)]
 
537
        return annotations
511
538
 
512
539
    def _get_ancestors(self, default_revision):
513
540
        ancestors = set([default_revision])
528
555
        else:
529
556
            parents = [last_rev]
530
557
        try:
531
 
            merges_file = self._transport.get('pending-merges')
 
558
            merges_bytes = self._transport.get_bytes('pending-merges')
532
559
        except errors.NoSuchFile:
533
560
            pass
534
561
        else:
535
 
            for l in merges_file.readlines():
 
562
            for l in osutils.split_lines(merges_bytes):
536
563
                revision_id = l.rstrip('\n')
537
564
                parents.append(revision_id)
538
565
        return parents
557
584
 
558
585
        revision
559
586
            If not None, the cloned tree will have its last revision set to
560
 
            revision, and and difference between the source trees last revision
 
587
            revision, and difference between the source trees last revision
561
588
            and this one merged in.
562
589
        """
563
590
        # assumes the target bzr dir format is compatible.
597
624
 
598
625
    def get_file_size(self, file_id):
599
626
        """See Tree.get_file_size"""
 
627
        # XXX: this returns the on-disk size; it should probably return the
 
628
        # canonical size
600
629
        try:
601
630
            return os.path.getsize(self.id2abspath(file_id))
602
631
        except OSError, e:
618
647
 
619
648
    def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
620
649
        file_id = self.path2id(path)
 
650
        if file_id is None:
 
651
            # For unversioned files on win32, we just assume they are not
 
652
            # executable
 
653
            return False
621
654
        return self._inventory[file_id].executable
622
655
 
623
656
    def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
733
766
            raise
734
767
        kind = _mapper(stat_result.st_mode)
735
768
        if kind == 'file':
736
 
            size = stat_result.st_size
737
 
            # try for a stat cache lookup
738
 
            executable = self._is_executable_from_path_and_stat(path, stat_result)
739
 
            return (kind, size, executable, self._sha_from_stat(
740
 
                path, stat_result))
 
769
            return self._file_content_summary(path, stat_result)
741
770
        elif kind == 'directory':
742
771
            # perhaps it looks like a plain directory, but it's really a
743
772
            # reference.
745
774
                kind = 'tree-reference'
746
775
            return kind, None, None, None
747
776
        elif kind == 'symlink':
748
 
            return ('symlink', None, None,
749
 
                    os.readlink(abspath.encode(osutils._fs_enc)
750
 
                                ).decode(osutils._fs_enc))
 
777
            target = osutils.readlink(abspath)
 
778
            return ('symlink', None, None, target)
751
779
        else:
752
780
            return (kind, None, None, None)
753
781
 
 
782
    def _file_content_summary(self, path, stat_result):
 
783
        size = stat_result.st_size
 
784
        executable = self._is_executable_from_path_and_stat(path, stat_result)
 
785
        # try for a stat cache lookup
 
786
        return ('file', size, executable, self._sha_from_stat(
 
787
            path, stat_result))
 
788
 
754
789
    def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):
755
790
        """Common ghost checking functionality from set_parent_*.
756
791
 
876
911
 
877
912
    @needs_write_lock # because merge pulls data into the branch.
878
913
    def merge_from_branch(self, branch, to_revision=None, from_revision=None,
879
 
        merge_type=None):
 
914
                          merge_type=None, force=False):
880
915
        """Merge from a branch into this working tree.
881
916
 
882
917
        :param branch: The branch to merge from.
886
921
            branch.last_revision().
887
922
        """
888
923
        from bzrlib.merge import Merger, Merge3Merger
889
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
890
 
        try:
891
 
            merger = Merger(self.branch, this_tree=self, pb=pb)
892
 
            merger.pp = ProgressPhase("Merge phase", 5, pb)
893
 
            merger.pp.next_phase()
894
 
            # check that there are no
895
 
            # local alterations
896
 
            merger.check_basis(check_clean=True, require_commits=False)
897
 
            if to_revision is None:
898
 
                to_revision = _mod_revision.ensure_null(branch.last_revision())
899
 
            merger.other_rev_id = to_revision
900
 
            if _mod_revision.is_null(merger.other_rev_id):
901
 
                raise errors.NoCommits(branch)
902
 
            self.branch.fetch(branch, last_revision=merger.other_rev_id)
903
 
            merger.other_basis = merger.other_rev_id
904
 
            merger.other_tree = self.branch.repository.revision_tree(
905
 
                merger.other_rev_id)
906
 
            merger.other_branch = branch
907
 
            merger.pp.next_phase()
908
 
            if from_revision is None:
909
 
                merger.find_base()
910
 
            else:
911
 
                merger.set_base_revision(from_revision, branch)
912
 
            if merger.base_rev_id == merger.other_rev_id:
913
 
                raise errors.PointlessMerge
914
 
            merger.backup_files = False
915
 
            if merge_type is None:
916
 
                merger.merge_type = Merge3Merger
917
 
            else:
918
 
                merger.merge_type = merge_type
919
 
            merger.set_interesting_files(None)
920
 
            merger.show_base = False
921
 
            merger.reprocess = False
922
 
            conflicts = merger.do_merge()
923
 
            merger.set_pending()
924
 
        finally:
925
 
            pb.finished()
 
924
        merger = Merger(self.branch, this_tree=self)
 
925
        # check that there are no local alterations
 
926
        if not force and self.has_changes():
 
927
            raise errors.UncommittedChanges(self)
 
928
        if to_revision is None:
 
929
            to_revision = _mod_revision.ensure_null(branch.last_revision())
 
930
        merger.other_rev_id = to_revision
 
931
        if _mod_revision.is_null(merger.other_rev_id):
 
932
            raise errors.NoCommits(branch)
 
933
        self.branch.fetch(branch, last_revision=merger.other_rev_id)
 
934
        merger.other_basis = merger.other_rev_id
 
935
        merger.other_tree = self.branch.repository.revision_tree(
 
936
            merger.other_rev_id)
 
937
        merger.other_branch = branch
 
938
        if from_revision is None:
 
939
            merger.find_base()
 
940
        else:
 
941
            merger.set_base_revision(from_revision, branch)
 
942
        if merger.base_rev_id == merger.other_rev_id:
 
943
            raise errors.PointlessMerge
 
944
        merger.backup_files = False
 
945
        if merge_type is None:
 
946
            merger.merge_type = Merge3Merger
 
947
        else:
 
948
            merger.merge_type = merge_type
 
949
        merger.set_interesting_files(None)
 
950
        merger.show_base = False
 
951
        merger.reprocess = False
 
952
        conflicts = merger.do_merge()
 
953
        merger.set_pending()
926
954
        return conflicts
927
955
 
928
956
    @needs_read_lock
969
997
        return file_id
970
998
 
971
999
    def get_symlink_target(self, file_id):
972
 
        return os.readlink(self.id2abspath(file_id).encode(osutils._fs_enc))
 
1000
        abspath = self.id2abspath(file_id)
 
1001
        target = osutils.readlink(abspath)
 
1002
        return target
973
1003
 
974
1004
    @needs_write_lock
975
1005
    def subsume(self, other_tree):
1073
1103
        tree_transport = self.bzrdir.root_transport.clone(sub_path)
1074
1104
        if tree_transport.base != branch_transport.base:
1075
1105
            tree_bzrdir = format.initialize_on_transport(tree_transport)
1076
 
            branch.BranchReferenceFormat().initialize(tree_bzrdir, new_branch)
 
1106
            branch.BranchReferenceFormat().initialize(tree_bzrdir,
 
1107
                target_branch=new_branch)
1077
1108
        else:
1078
1109
            tree_bzrdir = branch_bzrdir
1079
 
        wt = tree_bzrdir.create_workingtree(NULL_REVISION)
 
1110
        wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
1080
1111
        wt.set_parent_ids(self.get_parent_ids())
1081
1112
        my_inv = self.inventory
1082
 
        child_inv = Inventory(root_id=None)
 
1113
        child_inv = inventory.Inventory(root_id=None)
1083
1114
        new_root = my_inv[file_id]
1084
1115
        my_inv.remove_recursive_id(file_id)
1085
1116
        new_root.parent_id = None
1110
1141
    def _kind(self, relpath):
1111
1142
        return osutils.file_kind(self.abspath(relpath))
1112
1143
 
1113
 
    def list_files(self, include_root=False):
1114
 
        """Recursively list all files as (path, class, kind, id, entry).
 
1144
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
1145
        """List all files as (path, class, kind, id, entry).
1115
1146
 
1116
1147
        Lists, but does not descend into unversioned directories.
1117
 
 
1118
1148
        This does not include files that have been deleted in this
1119
 
        tree.
 
1149
        tree. Skips the control directory.
1120
1150
 
1121
 
        Skips the control directory.
 
1151
        :param include_root: if True, return an entry for the root
 
1152
        :param from_dir: start from this directory or None for the root
 
1153
        :param recursive: whether to recurse into subdirectories or not
1122
1154
        """
1123
1155
        # list_files is an iterator, so @needs_read_lock doesn't work properly
1124
1156
        # with it. So callers should be careful to always read_lock the tree.
1126
1158
            raise errors.ObjectNotLocked(self)
1127
1159
 
1128
1160
        inv = self.inventory
1129
 
        if include_root is True:
 
1161
        if from_dir is None and include_root is True:
1130
1162
            yield ('', 'V', 'directory', inv.root.file_id, inv.root)
1131
1163
        # Convert these into local objects to save lookup times
1132
1164
        pathjoin = osutils.pathjoin
1139
1171
        fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
1140
1172
 
1141
1173
        # directory file_id, relative path, absolute path, reverse sorted children
1142
 
        children = os.listdir(self.basedir)
 
1174
        if from_dir is not None:
 
1175
            from_dir_id = inv.path2id(from_dir)
 
1176
            if from_dir_id is None:
 
1177
                # Directory not versioned
 
1178
                return
 
1179
            from_dir_abspath = pathjoin(self.basedir, from_dir)
 
1180
        else:
 
1181
            from_dir_id = inv.root.file_id
 
1182
            from_dir_abspath = self.basedir
 
1183
        children = os.listdir(from_dir_abspath)
1143
1184
        children.sort()
1144
1185
        # jam 20060527 The kernel sized tree seems equivalent whether we
1145
1186
        # use a deque and popleft to keep them sorted, or if we use a plain
1146
1187
        # list and just reverse() them.
1147
1188
        children = collections.deque(children)
1148
 
        stack = [(inv.root.file_id, u'', self.basedir, children)]
 
1189
        stack = [(from_dir_id, u'', from_dir_abspath, children)]
1149
1190
        while stack:
1150
1191
            from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
1151
1192
 
1209
1250
                if fk != 'directory':
1210
1251
                    continue
1211
1252
 
1212
 
                # But do this child first
1213
 
                new_children = os.listdir(fap)
1214
 
                new_children.sort()
1215
 
                new_children = collections.deque(new_children)
1216
 
                stack.append((f_ie.file_id, fp, fap, new_children))
1217
 
                # Break out of inner loop,
1218
 
                # so that we start outer loop with child
1219
 
                break
 
1253
                # But do this child first if recursing down
 
1254
                if recursive:
 
1255
                    new_children = os.listdir(fap)
 
1256
                    new_children.sort()
 
1257
                    new_children = collections.deque(new_children)
 
1258
                    stack.append((f_ie.file_id, fp, fap, new_children))
 
1259
                    # Break out of inner loop,
 
1260
                    # so that we start outer loop with child
 
1261
                    break
1220
1262
            else:
1221
1263
                # if we finished all children, pop it off the stack
1222
1264
                stack.pop()
1400
1442
        inv = self.inventory
1401
1443
        for entry in moved:
1402
1444
            try:
1403
 
                self._move_entry(_RenameEntry(entry.to_rel, entry.from_id,
 
1445
                self._move_entry(WorkingTree._RenameEntry(
 
1446
                    entry.to_rel, entry.from_id,
1404
1447
                    entry.to_tail, entry.to_parent_id, entry.from_rel,
1405
1448
                    entry.from_tail, entry.from_parent_id,
1406
1449
                    entry.only_change_inv))
1457
1500
        from_tail = splitpath(from_rel)[-1]
1458
1501
        from_id = inv.path2id(from_rel)
1459
1502
        if from_id is None:
1460
 
            raise errors.BzrRenameFailedError(from_rel,to_rel,
1461
 
                errors.NotVersionedError(path=str(from_rel)))
1462
 
        from_entry = inv[from_id]
 
1503
            # if file is missing in the inventory maybe it's in the basis_tree
 
1504
            basis_tree = self.branch.basis_tree()
 
1505
            from_id = basis_tree.path2id(from_rel)
 
1506
            if from_id is None:
 
1507
                raise errors.BzrRenameFailedError(from_rel,to_rel,
 
1508
                    errors.NotVersionedError(path=str(from_rel)))
 
1509
            # put entry back in the inventory so we can rename it
 
1510
            from_entry = basis_tree.inventory[from_id].copy()
 
1511
            inv.add(from_entry)
 
1512
        else:
 
1513
            from_entry = inv[from_id]
1463
1514
        from_parent_id = from_entry.parent_id
1464
1515
        to_dir, to_tail = os.path.split(to_rel)
1465
1516
        to_dir_id = inv.path2id(to_dir)
1527
1578
        :raises: NoSuchId if any fileid is not currently versioned.
1528
1579
        """
1529
1580
        for file_id in file_ids:
 
1581
            if file_id not in self._inventory:
 
1582
                raise errors.NoSuchId(self, file_id)
 
1583
        for file_id in file_ids:
1530
1584
            if self._inventory.has_id(file_id):
1531
1585
                self._inventory.remove_recursive_id(file_id)
1532
 
            else:
1533
 
                raise errors.NoSuchId(self, file_id)
1534
1586
        if len(file_ids):
1535
1587
            # in the future this should just set a dirty bit to wait for the
1536
1588
            # final unlock. However, until all methods of workingtree start
1555
1607
 
1556
1608
    @needs_write_lock
1557
1609
    def pull(self, source, overwrite=False, stop_revision=None,
1558
 
             change_reporter=None, possible_transports=None):
1559
 
        top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1610
             change_reporter=None, possible_transports=None, local=False):
1560
1611
        source.lock_read()
1561
1612
        try:
1562
 
            pp = ProgressPhase("Pull phase", 2, top_pb)
1563
 
            pp.next_phase()
1564
1613
            old_revision_info = self.branch.last_revision_info()
1565
1614
            basis_tree = self.basis_tree()
1566
1615
            count = self.branch.pull(source, overwrite, stop_revision,
1567
 
                                     possible_transports=possible_transports)
 
1616
                                     possible_transports=possible_transports,
 
1617
                                     local=local)
1568
1618
            new_revision_info = self.branch.last_revision_info()
1569
1619
            if new_revision_info != old_revision_info:
1570
 
                pp.next_phase()
1571
1620
                repository = self.branch.repository
1572
 
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
1573
1621
                basis_tree.lock_read()
1574
1622
                try:
1575
1623
                    new_basis_tree = self.branch.basis_tree()
1578
1626
                                new_basis_tree,
1579
1627
                                basis_tree,
1580
1628
                                this_tree=self,
1581
 
                                pb=pb,
 
1629
                                pb=None,
1582
1630
                                change_reporter=change_reporter)
1583
 
                    if (basis_tree.inventory.root is None and
1584
 
                        new_basis_tree.inventory.root is not None):
1585
 
                        self.set_root_id(new_basis_tree.get_root_id())
 
1631
                    basis_root_id = basis_tree.get_root_id()
 
1632
                    new_root_id = new_basis_tree.get_root_id()
 
1633
                    if basis_root_id != new_root_id:
 
1634
                        self.set_root_id(new_root_id)
1586
1635
                finally:
1587
 
                    pb.finished()
1588
1636
                    basis_tree.unlock()
1589
1637
                # TODO - dedup parents list with things merged by pull ?
1590
1638
                # reuse the revisiontree we merged against to set the new
1603
1651
            return count
1604
1652
        finally:
1605
1653
            source.unlock()
1606
 
            top_pb.finished()
1607
1654
 
1608
1655
    @needs_write_lock
1609
1656
    def put_file_bytes_non_atomic(self, file_id, bytes):
1635
1682
 
1636
1683
            fl = []
1637
1684
            for subf in os.listdir(dirabs):
1638
 
                if subf == '.bzr':
 
1685
                if self.bzrdir.is_control_filename(subf):
1639
1686
                    continue
1640
1687
                if subf not in dir_entry.children:
1641
1688
                    try:
1694
1741
        r"""Check whether the filename matches an ignore pattern.
1695
1742
 
1696
1743
        Patterns containing '/' or '\' need to match the whole path;
1697
 
        others match against only the last component.
 
1744
        others match against only the last component.  Patterns starting
 
1745
        with '!' are ignore exceptions.  Exceptions take precedence
 
1746
        over regular patterns and cause the filename to not be ignored.
1698
1747
 
1699
1748
        If the file is ignored, returns the pattern which caused it to
1700
1749
        be ignored, otherwise None.  So this can simply be used as a
1701
1750
        boolean if desired."""
1702
1751
        if getattr(self, '_ignoreglobster', None) is None:
1703
 
            self._ignoreglobster = globbing.Globster(self.get_ignore_list())
 
1752
            self._ignoreglobster = globbing.ExceptionGlobster(self.get_ignore_list())
1704
1753
        return self._ignoreglobster.match(filename)
1705
1754
 
1706
1755
    def kind(self, file_id):
1756
1805
            raise errors.ObjectNotLocked(self)
1757
1806
 
1758
1807
    def lock_read(self):
1759
 
        """See Branch.lock_read, and WorkingTree.unlock."""
 
1808
        """Lock the tree for reading.
 
1809
 
 
1810
        This also locks the branch, and can be unlocked via self.unlock().
 
1811
 
 
1812
        :return: A bzrlib.lock.LogicalLockResult.
 
1813
        """
1760
1814
        if not self.is_locked():
1761
1815
            self._reset_data()
1762
1816
        self.branch.lock_read()
1763
1817
        try:
1764
 
            return self._control_files.lock_read()
 
1818
            self._control_files.lock_read()
 
1819
            return LogicalLockResult(self.unlock)
1765
1820
        except:
1766
1821
            self.branch.unlock()
1767
1822
            raise
1768
1823
 
1769
1824
    def lock_tree_write(self):
1770
 
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
 
1825
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
 
1826
 
 
1827
        :return: A bzrlib.lock.LogicalLockResult.
 
1828
        """
1771
1829
        if not self.is_locked():
1772
1830
            self._reset_data()
1773
1831
        self.branch.lock_read()
1774
1832
        try:
1775
 
            return self._control_files.lock_write()
 
1833
            self._control_files.lock_write()
 
1834
            return LogicalLockResult(self.unlock)
1776
1835
        except:
1777
1836
            self.branch.unlock()
1778
1837
            raise
1779
1838
 
1780
1839
    def lock_write(self):
1781
 
        """See MutableTree.lock_write, and WorkingTree.unlock."""
 
1840
        """See MutableTree.lock_write, and WorkingTree.unlock.
 
1841
 
 
1842
        :return: A bzrlib.lock.LogicalLockResult.
 
1843
        """
1782
1844
        if not self.is_locked():
1783
1845
            self._reset_data()
1784
1846
        self.branch.lock_write()
1785
1847
        try:
1786
 
            return self._control_files.lock_write()
 
1848
            self._control_files.lock_write()
 
1849
            return LogicalLockResult(self.unlock)
1787
1850
        except:
1788
1851
            self.branch.unlock()
1789
1852
            raise
1797
1860
    def _reset_data(self):
1798
1861
        """Reset transient data that cannot be revalidated."""
1799
1862
        self._inventory_is_modified = False
1800
 
        result = self._deserialize(self._transport.get('inventory'))
 
1863
        f = self._transport.get('inventory')
 
1864
        try:
 
1865
            result = self._deserialize(f)
 
1866
        finally:
 
1867
            f.close()
1801
1868
        self._set_inventory(result, dirty=False)
1802
1869
 
1803
1870
    @needs_tree_write_lock
1850
1917
            # revision_id is set. We must check for this full string, because a
1851
1918
            # root node id can legitimately look like 'revision_id' but cannot
1852
1919
            # contain a '"'.
1853
 
            xml = self.branch.repository.get_inventory_xml(new_revision)
 
1920
            xml = self.branch.repository._get_inventory_xml(new_revision)
1854
1921
            firstline = xml.split('\n', 1)[0]
1855
1922
            if (not 'revision_id="' in firstline or
1856
1923
                'format="7"' not in firstline):
1857
 
                inv = self.branch.repository.deserialise_inventory(
1858
 
                    new_revision, xml)
 
1924
                inv = self.branch.repository._serializer.read_inventory_from_string(
 
1925
                    xml, new_revision)
1859
1926
                xml = self._create_basis_xml_from_inventory(new_revision, inv)
1860
1927
            self._write_basis_inventory(xml)
1861
1928
        except (errors.NoSuchRevision, errors.RevisionNotPresent):
1879
1946
        # binary.
1880
1947
        if self._inventory_is_modified:
1881
1948
            raise errors.InventoryModified(self)
1882
 
        result = self._deserialize(self._transport.get('inventory'))
 
1949
        f = self._transport.get('inventory')
 
1950
        try:
 
1951
            result = self._deserialize(f)
 
1952
        finally:
 
1953
            f.close()
1883
1954
        self._set_inventory(result, dirty=False)
1884
1955
        return result
1885
1956
 
1900
1971
 
1901
1972
        new_files=set()
1902
1973
        unknown_nested_files=set()
 
1974
        if to_file is None:
 
1975
            to_file = sys.stdout
1903
1976
 
1904
1977
        def recurse_directory_to_add_files(directory):
1905
1978
            # Recurse directory and add all files
1906
1979
            # so we can check if they have changed.
1907
 
            for parent_info, file_infos in\
1908
 
                self.walkdirs(directory):
 
1980
            for parent_info, file_infos in self.walkdirs(directory):
1909
1981
                for relpath, basename, kind, lstat, fileid, kind in file_infos:
1910
1982
                    # Is it versioned or ignored?
1911
1983
                    if self.path2id(relpath) or self.is_ignored(relpath):
1946
2018
                            # ... but not ignored
1947
2019
                            has_changed_files = True
1948
2020
                            break
1949
 
                    elif content_change and (kind[1] is not None):
1950
 
                        # Versioned and changed, but not deleted
 
2021
                    elif (content_change and (kind[1] is not None) and
 
2022
                            osutils.is_inside_any(files, path[1])):
 
2023
                        # Versioned and changed, but not deleted, and still
 
2024
                        # in one of the dirs to be deleted.
1951
2025
                        has_changed_files = True
1952
2026
                        break
1953
2027
 
1961
2035
                        tree_delta.unversioned.extend((unknown_file,))
1962
2036
                raise errors.BzrRemoveChangedFilesError(tree_delta)
1963
2037
 
1964
 
        # Build inv_delta and delete files where applicaple,
 
2038
        # Build inv_delta and delete files where applicable,
1965
2039
        # do this before any modifications to inventory.
1966
2040
        for f in files:
1967
2041
            fid = self.path2id(f)
1975
2049
                        new_status = 'I'
1976
2050
                    else:
1977
2051
                        new_status = '?'
1978
 
                    textui.show_status(new_status, self.kind(fid), f,
1979
 
                                       to_file=to_file)
 
2052
                    # XXX: Really should be a more abstract reporter interface
 
2053
                    kind_ch = osutils.kind_marker(self.kind(fid))
 
2054
                    to_file.write(new_status + '       ' + f + kind_ch + '\n')
1980
2055
                # Unversion file
1981
2056
                inv_delta.append((f, None, fid, None))
1982
2057
                message = "removed %s" % (f,)
2005
2080
 
2006
2081
    @needs_tree_write_lock
2007
2082
    def revert(self, filenames=None, old_tree=None, backups=True,
2008
 
               pb=DummyProgress(), report_changes=False):
 
2083
               pb=None, report_changes=False):
2009
2084
        from bzrlib.conflicts import resolve
2010
2085
        if filenames == []:
2011
2086
            filenames = None
2024
2099
            if filenames is None and len(self.get_parent_ids()) > 1:
2025
2100
                parent_trees = []
2026
2101
                last_revision = self.last_revision()
2027
 
                if last_revision != NULL_REVISION:
 
2102
                if last_revision != _mod_revision.NULL_REVISION:
2028
2103
                    if basis_tree is None:
2029
2104
                        basis_tree = self.basis_tree()
2030
2105
                        basis_tree.lock_read()
2068
2143
    def set_inventory(self, new_inventory_list):
2069
2144
        from bzrlib.inventory import (Inventory,
2070
2145
                                      InventoryDirectory,
2071
 
                                      InventoryEntry,
2072
2146
                                      InventoryFile,
2073
2147
                                      InventoryLink)
2074
2148
        inv = Inventory(self.get_root_id())
2134
2208
        """
2135
2209
        raise NotImplementedError(self.unlock)
2136
2210
 
2137
 
    def update(self, change_reporter=None, possible_transports=None):
 
2211
    _marker = object()
 
2212
 
 
2213
    def update(self, change_reporter=None, possible_transports=None,
 
2214
               revision=None, old_tip=_marker):
2138
2215
        """Update a working tree along its branch.
2139
2216
 
2140
2217
        This will update the branch if its bound too, which means we have
2158
2235
        - Merge current state -> basis tree of the master w.r.t. the old tree
2159
2236
          basis.
2160
2237
        - Do a 'normal' merge of the old branch basis if it is relevant.
 
2238
 
 
2239
        :param revision: The target revision to update to. Must be in the
 
2240
            revision history.
 
2241
        :param old_tip: If branch.update() has already been run, the value it
 
2242
            returned (old tip of the branch or None). _marker is used
 
2243
            otherwise.
2161
2244
        """
2162
2245
        if self.branch.get_bound_location() is not None:
2163
2246
            self.lock_write()
2164
 
            update_branch = True
 
2247
            update_branch = (old_tip is self._marker)
2165
2248
        else:
2166
2249
            self.lock_tree_write()
2167
2250
            update_branch = False
2169
2252
            if update_branch:
2170
2253
                old_tip = self.branch.update(possible_transports)
2171
2254
            else:
2172
 
                old_tip = None
2173
 
            return self._update_tree(old_tip, change_reporter)
 
2255
                if old_tip is self._marker:
 
2256
                    old_tip = None
 
2257
            return self._update_tree(old_tip, change_reporter, revision)
2174
2258
        finally:
2175
2259
            self.unlock()
2176
2260
 
2177
2261
    @needs_tree_write_lock
2178
 
    def _update_tree(self, old_tip=None, change_reporter=None):
 
2262
    def _update_tree(self, old_tip=None, change_reporter=None, revision=None):
2179
2263
        """Update a tree to the master branch.
2180
2264
 
2181
2265
        :param old_tip: if supplied, the previous tip revision the branch,
2191
2275
        # We MUST save it even if an error occurs, because otherwise the users
2192
2276
        # local work is unreferenced and will appear to have been lost.
2193
2277
        #
2194
 
        result = 0
 
2278
        nb_conflicts = 0
2195
2279
        try:
2196
2280
            last_rev = self.get_parent_ids()[0]
2197
2281
        except IndexError:
2198
2282
            last_rev = _mod_revision.NULL_REVISION
2199
 
        if last_rev != _mod_revision.ensure_null(self.branch.last_revision()):
2200
 
            # merge tree state up to new branch tip.
 
2283
        if revision is None:
 
2284
            revision = self.branch.last_revision()
 
2285
 
 
2286
        old_tip = old_tip or _mod_revision.NULL_REVISION
 
2287
 
 
2288
        if not _mod_revision.is_null(old_tip) and old_tip != last_rev:
 
2289
            # the branch we are bound to was updated
 
2290
            # merge those changes in first
 
2291
            base_tree  = self.basis_tree()
 
2292
            other_tree = self.branch.repository.revision_tree(old_tip)
 
2293
            nb_conflicts = merge.merge_inner(self.branch, other_tree,
 
2294
                                             base_tree, this_tree=self,
 
2295
                                             change_reporter=change_reporter)
 
2296
            if nb_conflicts:
 
2297
                self.add_parent_tree((old_tip, other_tree))
 
2298
                trace.note('Rerun update after fixing the conflicts.')
 
2299
                return nb_conflicts
 
2300
 
 
2301
        if last_rev != _mod_revision.ensure_null(revision):
 
2302
            # the working tree is up to date with the branch
 
2303
            # we can merge the specified revision from master
 
2304
            to_tree = self.branch.repository.revision_tree(revision)
 
2305
            to_root_id = to_tree.get_root_id()
 
2306
 
2201
2307
            basis = self.basis_tree()
2202
2308
            basis.lock_read()
2203
2309
            try:
2204
 
                to_tree = self.branch.basis_tree()
2205
 
                if basis.inventory.root is None:
2206
 
                    self.set_root_id(to_tree.get_root_id())
 
2310
                if (basis.inventory.root is None
 
2311
                    or basis.inventory.root.file_id != to_root_id):
 
2312
                    self.set_root_id(to_root_id)
2207
2313
                    self.flush()
2208
 
                result += merge.merge_inner(
2209
 
                                      self.branch,
2210
 
                                      to_tree,
2211
 
                                      basis,
2212
 
                                      this_tree=self,
2213
 
                                      change_reporter=change_reporter)
2214
2314
            finally:
2215
2315
                basis.unlock()
 
2316
 
 
2317
            # determine the branch point
 
2318
            graph = self.branch.repository.get_graph()
 
2319
            base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
 
2320
                                                last_rev)
 
2321
            base_tree = self.branch.repository.revision_tree(base_rev_id)
 
2322
 
 
2323
            nb_conflicts = merge.merge_inner(self.branch, to_tree, base_tree,
 
2324
                                             this_tree=self,
 
2325
                                             change_reporter=change_reporter)
 
2326
            self.set_last_revision(revision)
2216
2327
            # TODO - dedup parents list with things merged by pull ?
2217
2328
            # reuse the tree we've updated to to set the basis:
2218
 
            parent_trees = [(self.branch.last_revision(), to_tree)]
 
2329
            parent_trees = [(revision, to_tree)]
2219
2330
            merges = self.get_parent_ids()[1:]
2220
2331
            # Ideally we ask the tree for the trees here, that way the working
2221
 
            # tree can decide whether to give us teh entire tree or give us a
 
2332
            # tree can decide whether to give us the entire tree or give us a
2222
2333
            # lazy initialised tree. dirstate for instance will have the trees
2223
2334
            # in ram already, whereas a last-revision + basis-inventory tree
2224
2335
            # will not, but also does not need them when setting parents.
2225
2336
            for parent in merges:
2226
2337
                parent_trees.append(
2227
2338
                    (parent, self.branch.repository.revision_tree(parent)))
2228
 
            if (old_tip is not None and not _mod_revision.is_null(old_tip)):
 
2339
            if not _mod_revision.is_null(old_tip):
2229
2340
                parent_trees.append(
2230
2341
                    (old_tip, self.branch.repository.revision_tree(old_tip)))
2231
2342
            self.set_parent_trees(parent_trees)
2232
2343
            last_rev = parent_trees[0][0]
2233
 
        else:
2234
 
            # the working tree had the same last-revision as the master
2235
 
            # branch did. We may still have pivot local work from the local
2236
 
            # branch into old_tip:
2237
 
            if (old_tip is not None and not _mod_revision.is_null(old_tip)):
2238
 
                self.add_parent_tree_id(old_tip)
2239
 
        if (old_tip is not None and not _mod_revision.is_null(old_tip)
2240
 
            and old_tip != last_rev):
2241
 
            # our last revision was not the prior branch last revision
2242
 
            # and we have converted that last revision to a pending merge.
2243
 
            # base is somewhere between the branch tip now
2244
 
            # and the now pending merge
2245
 
 
2246
 
            # Since we just modified the working tree and inventory, flush out
2247
 
            # the current state, before we modify it again.
2248
 
            # TODO: jam 20070214 WorkingTree3 doesn't require this, dirstate
2249
 
            #       requires it only because TreeTransform directly munges the
2250
 
            #       inventory and calls tree._write_inventory(). Ultimately we
2251
 
            #       should be able to remove this extra flush.
2252
 
            self.flush()
2253
 
            graph = self.branch.repository.get_graph()
2254
 
            base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
2255
 
                                                old_tip)
2256
 
            base_tree = self.branch.repository.revision_tree(base_rev_id)
2257
 
            other_tree = self.branch.repository.revision_tree(old_tip)
2258
 
            result += merge.merge_inner(
2259
 
                                  self.branch,
2260
 
                                  other_tree,
2261
 
                                  base_tree,
2262
 
                                  this_tree=self,
2263
 
                                  change_reporter=change_reporter)
2264
 
        return result
 
2344
        return nb_conflicts
2265
2345
 
2266
2346
    def _write_hashcache_if_dirty(self):
2267
2347
        """Write out the hashcache if it is dirty."""
2367
2447
                    bzrdir_loc = bisect_left(cur_disk_dir_content,
2368
2448
                        ('.bzr', '.bzr'))
2369
2449
                    if (bzrdir_loc < len(cur_disk_dir_content)
2370
 
                        and cur_disk_dir_content[bzrdir_loc][0] == '.bzr'):
 
2450
                        and self.bzrdir.is_control_filename(
 
2451
                            cur_disk_dir_content[bzrdir_loc][0])):
2371
2452
                        # we dont yield the contents of, or, .bzr itself.
2372
2453
                        del cur_disk_dir_content[bzrdir_loc]
2373
2454
            if inv_finished:
2507
2588
        return un_resolved, resolved
2508
2589
 
2509
2590
    @needs_read_lock
2510
 
    def _check(self):
 
2591
    def _check(self, references):
 
2592
        """Check the tree for consistency.
 
2593
 
 
2594
        :param references: A dict with keys matching the items returned by
 
2595
            self._get_check_refs(), and values from looking those keys up in
 
2596
            the repository.
 
2597
        """
2511
2598
        tree_basis = self.basis_tree()
2512
2599
        tree_basis.lock_read()
2513
2600
        try:
2514
 
            repo_basis = self.branch.repository.revision_tree(
2515
 
                self.last_revision())
 
2601
            repo_basis = references[('trees', self.last_revision())]
2516
2602
            if len(list(repo_basis.iter_changes(tree_basis))) > 0:
2517
2603
                raise errors.BzrCheckError(
2518
2604
                    "Mismatched basis inventory content.")
2531
2617
        """
2532
2618
        return
2533
2619
 
2534
 
    @needs_read_lock
2535
2620
    def _get_rules_searcher(self, default_searcher):
2536
2621
        """See Tree._get_rules_searcher."""
2537
2622
        if self._rules_searcher is None:
2564
2649
        if self._inventory is None:
2565
2650
            self.read_working_inventory()
2566
2651
 
 
2652
    def _get_check_refs(self):
 
2653
        """Return the references needed to perform a check of this tree."""
 
2654
        return [('trees', self.last_revision())]
 
2655
 
2567
2656
    def lock_tree_write(self):
2568
2657
        """See WorkingTree.lock_tree_write().
2569
2658
 
2570
2659
        In Format2 WorkingTrees we have a single lock for the branch and tree
2571
2660
        so lock_tree_write() degrades to lock_write().
 
2661
 
 
2662
        :return: An object with an unlock method which will release the lock
 
2663
            obtained.
2572
2664
        """
2573
2665
        self.branch.lock_write()
2574
2666
        try:
2575
 
            return self._control_files.lock_write()
 
2667
            self._control_files.lock_write()
 
2668
            return self
2576
2669
        except:
2577
2670
            self.branch.unlock()
2578
2671
            raise
2615
2708
 
2616
2709
    def _change_last_revision(self, revision_id):
2617
2710
        """See WorkingTree._change_last_revision."""
2618
 
        if revision_id is None or revision_id == NULL_REVISION:
 
2711
        if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
2619
2712
            try:
2620
2713
                self._transport.delete('last-revision')
2621
2714
            except errors.NoSuchFile:
2626
2719
                mode=self.bzrdir._get_file_mode())
2627
2720
            return True
2628
2721
 
 
2722
    def _get_check_refs(self):
 
2723
        """Return the references needed to perform a check of this tree."""
 
2724
        return [('trees', self.last_revision())]
 
2725
 
2629
2726
    @needs_tree_write_lock
2630
2727
    def set_conflicts(self, conflicts):
2631
2728
        self._put_rio('conflicts', conflicts.to_stanzas(),
2708
2805
        """Return the format for the working tree object in a_bzrdir."""
2709
2806
        try:
2710
2807
            transport = a_bzrdir.get_workingtree_transport(None)
2711
 
            format_string = transport.get("format").read()
 
2808
            format_string = transport.get_bytes("format")
2712
2809
            return klass._formats[format_string]
2713
2810
        except errors.NoSuchFile:
2714
2811
            raise errors.NoWorkingTree(base=transport.base)
2785
2882
        no working tree.  (See bug #43064).
2786
2883
        """
2787
2884
        sio = StringIO()
2788
 
        inv = Inventory()
 
2885
        inv = inventory.Inventory()
2789
2886
        xml5.serializer_v5.write_inventory(inv, sio, working=True)
2790
2887
        sio.seek(0)
2791
2888
        transport.put_file('inventory', sio, file_mode)
2807
2904
            branch.generate_revision_history(revision_id)
2808
2905
        finally:
2809
2906
            branch.unlock()
2810
 
        inv = Inventory()
 
2907
        inv = inventory.Inventory()
2811
2908
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
2812
2909
                         branch,
2813
2910
                         inv,
2930
3027
            # only set an explicit root id if there is one to set.
2931
3028
            if basis_tree.inventory.root is not None:
2932
3029
                wt.set_root_id(basis_tree.get_root_id())
2933
 
            if revision_id == NULL_REVISION:
 
3030
            if revision_id == _mod_revision.NULL_REVISION:
2934
3031
                wt.set_parent_trees([])
2935
3032
            else:
2936
3033
                wt.set_parent_trees([(revision_id, basis_tree)])
2943
3040
        return wt
2944
3041
 
2945
3042
    def _initial_inventory(self):
2946
 
        return Inventory()
 
3043
        return inventory.Inventory()
2947
3044
 
2948
3045
    def __init__(self):
2949
3046
        super(WorkingTreeFormat3, self).__init__()
2978
3075
        return self.get_format_string()
2979
3076
 
2980
3077
 
2981
 
__default_format = WorkingTreeFormat4()
 
3078
__default_format = WorkingTreeFormat6()
2982
3079
WorkingTreeFormat.register_format(__default_format)
2983
3080
WorkingTreeFormat.register_format(WorkingTreeFormat5())
 
3081
WorkingTreeFormat.register_format(WorkingTreeFormat4())
2984
3082
WorkingTreeFormat.register_format(WorkingTreeFormat3())
2985
3083
WorkingTreeFormat.set_default_format(__default_format)
2986
3084
# formats which have no format string are not discoverable