~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

  • Committer: Aaron Bentley
  • Date: 2007-08-24 20:32:51 UTC
  • mto: This revision was merged to the branch mainline in revision 2767.
  • Revision ID: abentley@panoramicfeedback.com-20070824203251-rsbqb1zfn84kydta
'send' and 'bundle' now handle partial ranges correctly (#61685)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 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
 
34
41
import bzrlib
35
42
from bzrlib import (
36
43
    bzrdir,
37
44
    cache_utf8,
 
45
    conflicts as _mod_conflicts,
38
46
    debug,
 
47
    delta,
39
48
    dirstate,
40
49
    errors,
41
50
    generate_ids,
 
51
    globbing,
 
52
    hashcache,
 
53
    ignores,
 
54
    merge,
42
55
    osutils,
43
56
    revision as _mod_revision,
44
57
    revisiontree,
 
58
    textui,
45
59
    trace,
46
60
    transform,
47
 
    views,
 
61
    urlutils,
 
62
    xml5,
 
63
    xml6,
48
64
    )
49
65
import bzrlib.branch
 
66
from bzrlib.transport import get_transport
50
67
import bzrlib.ui
51
68
""")
52
69
 
 
70
from bzrlib import symbol_versioning
53
71
from bzrlib.decorators import needs_read_lock, needs_write_lock
54
 
from bzrlib.filters import filtered_input_file, internal_size_sha_file_byname
55
 
from bzrlib.inventory import Inventory, ROOT_ID, entry_factory
 
72
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, entry_factory
 
73
from bzrlib.lockable_files import LockableFiles, TransportLock
 
74
from bzrlib.lockdir import LockDir
56
75
import bzrlib.mutabletree
57
76
from bzrlib.mutabletree import needs_tree_write_lock
58
77
from bzrlib.osutils import (
59
78
    file_kind,
60
79
    isdir,
 
80
    normpath,
61
81
    pathjoin,
 
82
    rand_chars,
62
83
    realpath,
63
84
    safe_unicode,
 
85
    splitpath,
64
86
    )
65
 
from bzrlib.trace import mutter
 
87
from bzrlib.trace import mutter, note
66
88
from bzrlib.transport.local import LocalTransport
67
89
from bzrlib.tree import InterTree
 
90
from bzrlib.progress import DummyProgress, ProgressPhase
 
91
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
 
92
from bzrlib.rio import RioReader, rio_file, Stanza
 
93
from bzrlib.symbol_versioning import (deprecated_passed,
 
94
        deprecated_method,
 
95
        deprecated_function,
 
96
        DEPRECATED_PARAMETER,
 
97
        )
68
98
from bzrlib.tree import Tree
69
99
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
70
100
 
71
101
 
72
 
class DirStateWorkingTree(WorkingTree3):
 
102
# This is the Windows equivalent of ENOTDIR
 
103
# It is defined in pywin32.winerror, but we don't want a strong dependency for
 
104
# just an error code.
 
105
ERROR_PATH_NOT_FOUND = 3
 
106
ERROR_DIRECTORY = 267
 
107
 
 
108
 
 
109
class WorkingTree4(WorkingTree3):
 
110
    """This is the Format 4 working tree.
 
111
 
 
112
    This differs from WorkingTree3 by:
 
113
     - Having a consolidated internal dirstate, stored in a
 
114
       randomly-accessible sorted file on disk.
 
115
     - Not having a regular inventory attribute.  One can be synthesized 
 
116
       on demand but this is expensive and should be avoided.
 
117
 
 
118
    This is new in bzr 0.15.
 
119
    """
 
120
 
73
121
    def __init__(self, basedir,
74
122
                 branch,
75
123
                 _control_files=None,
84
132
        """
85
133
        self._format = _format
86
134
        self.bzrdir = _bzrdir
 
135
        from bzrlib.trace import note, mutter
 
136
        assert isinstance(basedir, basestring), \
 
137
            "base directory %r is not a string" % basedir
87
138
        basedir = safe_unicode(basedir)
88
139
        mutter("opening working tree %r", basedir)
89
140
        self._branch = branch
 
141
        assert isinstance(self.branch, bzrlib.branch.Branch), \
 
142
            "branch %r is not a Branch" % self.branch
90
143
        self.basedir = realpath(basedir)
91
144
        # if branch is at our basedir and is a format 6 or less
92
145
        # assume all other formats have their own control files.
 
146
        assert isinstance(_control_files, LockableFiles), \
 
147
            "_control_files must be a LockableFiles, not %r" % _control_files
93
148
        self._control_files = _control_files
94
 
        self._transport = self._control_files._transport
95
149
        self._dirty = None
96
150
        #-------------
97
151
        # during a read or write lock these objects are set, and are
99
153
        self._dirstate = None
100
154
        self._inventory = None
101
155
        #-------------
102
 
        self._setup_directory_is_tree_reference()
103
 
        self._detect_case_handling()
104
 
        self._rules_searcher = None
105
 
        self.views = self._make_views()
106
 
        #--- allow tests to select the dirstate iter_changes implementation
107
 
        self._iter_changes = dirstate._process_entry
108
156
 
109
157
    @needs_tree_write_lock
110
158
    def _add(self, files, ids, kinds):
112
160
        state = self.current_dirstate()
113
161
        for f, file_id, kind in zip(files, ids, kinds):
114
162
            f = f.strip('/')
 
163
            assert '//' not in f
 
164
            assert '..' not in f
115
165
            if self.path2id(f):
116
166
                # special case tree root handling.
117
167
                if f == '' and self.path2id(f) == ROOT_ID:
138
188
    @needs_tree_write_lock
139
189
    def add_reference(self, sub_tree):
140
190
        # use standard implementation, which calls back to self._add
141
 
        #
 
191
        # 
142
192
        # So we don't store the reference_revision in the working dirstate,
143
 
        # it's just recorded at the moment of commit.
 
193
        # it's just recorded at the moment of commit. 
144
194
        self._add_reference(sub_tree)
145
195
 
146
196
    def break_lock(self):
185
235
            WorkingTree3._comparison_data(self, entry, path)
186
236
        # it looks like a plain directory, but it's really a reference -- see
187
237
        # also kind()
188
 
        if (self._repo_supports_tree_reference and kind == 'directory'
189
 
            and entry is not None and entry.kind == 'tree-reference'):
 
238
        if (self._repo_supports_tree_reference and
 
239
            kind == 'directory' and
 
240
            self._directory_is_tree_reference(path)):
190
241
            kind = 'tree-reference'
191
242
        return kind, executable, stat_value
192
243
 
218
269
            return self._dirstate
219
270
        local_path = self.bzrdir.get_workingtree_transport(None
220
271
            ).local_abspath('dirstate')
221
 
        self._dirstate = dirstate.DirState.on_file(local_path,
222
 
            self._sha1_provider())
 
272
        self._dirstate = dirstate.DirState.on_file(local_path)
223
273
        return self._dirstate
224
274
 
225
 
    def _sha1_provider(self):
226
 
        """A function that returns a SHA1Provider suitable for this tree.
227
 
 
228
 
        :return: None if content filtering is not supported by this tree.
229
 
          Otherwise, a SHA1Provider is returned that sha's the canonical
230
 
          form of files, i.e. after read filters are applied.
231
 
        """
232
 
        if self.supports_content_filtering():
233
 
            return ContentFilterAwareSHA1Provider(self)
234
 
        else:
235
 
            return None
 
275
    def _directory_is_tree_reference(self, relpath):
 
276
        # as a special case, if a directory contains control files then 
 
277
        # it's a tree reference, except that the root of the tree is not
 
278
        return relpath and osutils.isdir(self.abspath(relpath) + u"/.bzr")
 
279
        # TODO: We could ask all the control formats whether they
 
280
        # recognize this directory, but at the moment there's no cheap api
 
281
        # to do that.  Since we probably can only nest bzr checkouts and
 
282
        # they always use this name it's ok for now.  -- mbp 20060306
 
283
        #
 
284
        # FIXME: There is an unhandled case here of a subdirectory
 
285
        # containing .bzr but not a branch; that will probably blow up
 
286
        # when you try to commit it.  It might happen if there is a
 
287
        # checkout in a subdirectory.  This can be avoided by not adding
 
288
        # it.  mbp 20070306
236
289
 
237
290
    def filter_unversioned_files(self, paths):
238
291
        """Filter out paths that are versioned.
271
324
 
272
325
    def _generate_inventory(self):
273
326
        """Create and set self.inventory from the dirstate object.
274
 
 
 
327
        
275
328
        This is relatively expensive: we have to walk the entire dirstate.
276
329
        Ideally we would not, and can deprecate this function.
277
330
        """
281
334
        state._read_dirblocks_if_needed()
282
335
        root_key, current_entry = self._get_entry(path='')
283
336
        current_id = root_key[2]
284
 
        if not (current_entry[0][0] == 'd'): # directory
285
 
            raise AssertionError(current_entry)
 
337
        assert current_entry[0][0] == 'd' # directory
286
338
        inv = Inventory(root_id=current_id)
287
339
        # Turn some things into local variables
288
340
        minikind_to_kind = dirstate.DirState._minikind_to_kind
321
373
                    # add this entry to the parent map.
322
374
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
323
375
                elif kind == 'tree-reference':
324
 
                    if not self._repo_supports_tree_reference:
325
 
                        raise errors.UnsupportedOperation(
326
 
                            self._generate_inventory,
327
 
                            self.branch.repository)
 
376
                    assert self._repo_supports_tree_reference, \
 
377
                        "repository of %r " \
 
378
                        "doesn't support tree references " \
 
379
                        "required by entry %r" \
 
380
                        % (self, name)
328
381
                    inv_entry.reference_revision = link_or_sha1 or None
329
382
                elif kind != 'symlink':
330
383
                    raise AssertionError("unknown kind %r" % kind)
331
384
                # These checks cost us around 40ms on a 55k entry tree
332
 
                if file_id in inv_byid:
333
 
                    raise AssertionError('file_id %s already in'
334
 
                        ' inventory as %s' % (file_id, inv_byid[file_id]))
335
 
                if name_unicode in parent_ie.children:
336
 
                    raise AssertionError('name %r already in parent'
337
 
                        % (name_unicode,))
 
385
                assert file_id not in inv_byid, ('file_id %s already in'
 
386
                    ' inventory as %s' % (file_id, inv_byid[file_id]))
 
387
                assert name_unicode not in parent_ie.children
338
388
                inv_byid[file_id] = inv_entry
339
389
                parent_ie.children[name_unicode] = inv_entry
340
390
        self._inventory = inv
345
395
        If either file_id or path is supplied, it is used as the key to lookup.
346
396
        If both are supplied, the fastest lookup is used, and an error is
347
397
        raised if they do not both point at the same row.
348
 
 
 
398
        
349
399
        :param file_id: An optional unicode file_id to be looked up.
350
400
        :param path: An optional unicode path to be looked up.
351
401
        :return: The dirstate row tuple for path/file_id, or (None, None)
375
425
                    return None
376
426
                else:
377
427
                    raise
378
 
        link_or_sha1 = dirstate.update_entry(state, entry, file_abspath,
379
 
            stat_value=stat_value)
 
428
        link_or_sha1 = state.update_entry(entry, file_abspath,
 
429
                                          stat_value=stat_value)
380
430
        if entry[1][0][0] == 'f':
381
 
            if link_or_sha1 is None:
382
 
                file_obj, statvalue = self.get_file_with_stat(file_id, path)
383
 
                try:
384
 
                    sha1 = osutils.sha_file(file_obj)
385
 
                finally:
386
 
                    file_obj.close()
387
 
                self._observed_sha1(file_id, path, (sha1, statvalue))
388
 
                return sha1
389
 
            else:
390
 
                return link_or_sha1
 
431
            return link_or_sha1
391
432
        return None
392
433
 
393
434
    def _get_inventory(self):
407
448
    @needs_read_lock
408
449
    def get_parent_ids(self):
409
450
        """See Tree.get_parent_ids.
410
 
 
 
451
        
411
452
        This implementation requests the ids list from the dirstate file.
412
453
        """
413
454
        return self.current_dirstate().get_parent_ids()
429
470
 
430
471
    def has_id(self, file_id):
431
472
        state = self.current_dirstate()
 
473
        file_id = osutils.safe_file_id(file_id)
432
474
        row, parents = self._get_entry(file_id=file_id)
433
475
        if row is None:
434
476
            return False
435
477
        return osutils.lexists(pathjoin(
436
478
                    self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
437
479
 
438
 
    def has_or_had_id(self, file_id):
439
 
        state = self.current_dirstate()
440
 
        row, parents = self._get_entry(file_id=file_id)
441
 
        return row is not None
442
 
 
443
480
    @needs_read_lock
444
481
    def id2path(self, file_id):
445
482
        "Convert a file-id to a path."
 
483
        file_id = osutils.safe_file_id(file_id)
446
484
        state = self.current_dirstate()
447
485
        entry = self._get_entry(file_id=file_id)
448
486
        if entry == (None, None):
450
488
        path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
451
489
        return path_utf8.decode('utf8')
452
490
 
453
 
    def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
454
 
        entry = self._get_entry(path=path)
455
 
        if entry == (None, None):
456
 
            return False # Missing entries are not executable
457
 
        return entry[1][0][3] # Executable?
458
 
 
459
491
    if not osutils.supports_executable():
460
492
        def is_executable(self, file_id, path=None):
461
493
            """Test if a file is executable or not.
462
494
 
463
495
            Note: The caller is expected to take a read-lock before calling this.
464
496
            """
 
497
            file_id = osutils.safe_file_id(file_id)
465
498
            entry = self._get_entry(file_id=file_id, path=path)
466
499
            if entry == (None, None):
467
500
                return False
468
501
            return entry[1][0][3]
469
 
 
470
 
        _is_executable_from_path_and_stat = \
471
 
            _is_executable_from_path_and_stat_from_basis
472
502
    else:
473
503
        def is_executable(self, file_id, path=None):
474
504
            """Test if a file is executable or not.
475
505
 
476
506
            Note: The caller is expected to take a read-lock before calling this.
477
507
            """
478
 
            self._must_be_locked()
479
508
            if not path:
 
509
                file_id = osutils.safe_file_id(file_id)
480
510
                path = self.id2path(file_id)
481
511
            mode = os.lstat(self.abspath(path)).st_mode
482
512
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
483
513
 
484
 
    def all_file_ids(self):
485
 
        """See Tree.iter_all_file_ids"""
486
 
        self._must_be_locked()
487
 
        result = set()
488
 
        for key, tree_details in self.current_dirstate()._iter_entries():
489
 
            if tree_details[0][0] in ('a', 'r'): # relocated
490
 
                continue
491
 
            result.add(key[2])
492
 
        return result
493
 
 
494
514
    @needs_read_lock
495
515
    def __iter__(self):
496
516
        """Iterate through file_ids for this tree.
509
529
        return iter(result)
510
530
 
511
531
    def iter_references(self):
512
 
        if not self._repo_supports_tree_reference:
513
 
            # When the repo doesn't support references, we will have nothing to
514
 
            # return
515
 
            return
516
532
        for key, tree_details in self.current_dirstate()._iter_entries():
517
533
            if tree_details[0][0] in ('a', 'r'): # absent, relocated
518
534
                # not relevant to the working tree
520
536
            if not key[1]:
521
537
                # the root is not a reference.
522
538
                continue
523
 
            relpath = pathjoin(key[0].decode('utf8'), key[1].decode('utf8'))
 
539
            path = pathjoin(self.basedir, key[0].decode('utf8'), key[1].decode('utf8'))
524
540
            try:
525
 
                if self._kind(relpath) == 'tree-reference':
526
 
                    yield relpath, key[2]
 
541
                if self._kind(path) == 'tree-reference':
 
542
                    yield path, key[2]
527
543
            except errors.NoSuchFile:
528
544
                # path is missing on disk.
529
545
                continue
530
546
 
531
 
    def _observed_sha1(self, file_id, path, (sha1, statvalue)):
532
 
        """See MutableTree._observed_sha1."""
533
 
        state = self.current_dirstate()
534
 
        entry = self._get_entry(file_id=file_id, path=path)
535
 
        state._observed_sha1(entry, sha1, statvalue)
536
 
 
537
547
    def kind(self, file_id):
538
548
        """Return the kind of a file.
539
549
 
543
553
        Note: The caller is expected to take a read-lock before calling this.
544
554
        """
545
555
        relpath = self.id2path(file_id)
546
 
        if relpath is None:
547
 
            raise AssertionError(
548
 
                "path for id {%s} is None!" % file_id)
 
556
        assert relpath != None, \
 
557
            "path for id {%s} is None!" % file_id
549
558
        return self._kind(relpath)
550
559
 
551
560
    def _kind(self, relpath):
552
561
        abspath = self.abspath(relpath)
553
562
        kind = file_kind(abspath)
554
 
        if (self._repo_supports_tree_reference and kind == 'directory'):
555
 
            entry = self._get_entry(path=relpath)
556
 
            if entry[1] is not None:
557
 
                if entry[1][0][0] == 't':
558
 
                    kind = 'tree-reference'
 
563
        if (self._repo_supports_tree_reference and
 
564
            kind == 'directory' and
 
565
            self._directory_is_tree_reference(relpath)):
 
566
            kind = 'tree-reference'
559
567
        return kind
560
568
 
561
569
    @needs_read_lock
624
632
        result = []
625
633
        if not from_paths:
626
634
            return result
 
635
 
627
636
        state = self.current_dirstate()
628
 
        if isinstance(from_paths, basestring):
629
 
            raise ValueError()
 
637
 
 
638
        assert not isinstance(from_paths, basestring)
630
639
        to_dir_utf8 = to_dir.encode('utf8')
631
640
        to_entry_dirname, to_basename = os.path.split(to_dir_utf8)
632
641
        id_index = state._get_id_index()
654
663
        if self._inventory is not None:
655
664
            update_inventory = True
656
665
            inv = self.inventory
 
666
            to_dir_ie = inv[to_dir_id]
657
667
            to_dir_id = to_entry[0][2]
658
 
            to_dir_ie = inv[to_dir_id]
659
668
        else:
660
669
            update_inventory = False
661
670
 
692
701
            from_entry = self._get_entry(path=from_rel)
693
702
            if from_entry == (None, None):
694
703
                raise errors.BzrMoveFailedError(from_rel,to_dir,
695
 
                    errors.NotVersionedError(path=from_rel))
 
704
                    errors.NotVersionedError(path=str(from_rel)))
696
705
 
697
706
            from_id = from_entry[0][2]
698
707
            to_rel = pathjoin(to_dir, from_tail)
725
734
                if from_missing: # implicitly just update our path mapping
726
735
                    move_file = False
727
736
                elif not after:
728
 
                    raise errors.RenameFailedFilesExist(from_rel, to_rel)
 
737
                    raise errors.RenameFailedFilesExist(from_rel, to_rel,
 
738
                        extra="(Use --after to update the Bazaar id)")
729
739
 
730
740
            rollbacks = []
731
741
            def rollback_rename():
787
797
                if minikind == 'd':
788
798
                    def update_dirblock(from_dir, to_key, to_dir_utf8):
789
799
                        """Recursively update all entries in this dirblock."""
790
 
                        if from_dir == '':
791
 
                            raise AssertionError("renaming root not supported")
 
800
                        assert from_dir != '', "renaming root not supported"
792
801
                        from_key = (from_dir, '')
793
802
                        from_block_idx, present = \
794
803
                            state._find_block_index_from_key(from_key)
807
816
 
808
817
                        # Grab a copy since move_one may update the list.
809
818
                        for entry in from_block[1][:]:
810
 
                            if not (entry[0][0] == from_dir):
811
 
                                raise AssertionError()
 
819
                            assert entry[0][0] == from_dir
812
820
                            cur_details = entry[1][0]
813
821
                            to_key = (to_dir_utf8, entry[0][1], entry[0][2])
814
822
                            from_path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
873
881
        for tree in trees:
874
882
            if not (isinstance(tree, DirStateRevisionTree) and tree._revision_id in
875
883
                parents):
876
 
                return super(DirStateWorkingTree, self).paths2ids(paths,
877
 
                    trees, require_versioned)
 
884
                return super(WorkingTree4, self).paths2ids(paths, trees, require_versioned)
878
885
        search_indexes = [0] + [1 + parents.index(tree._revision_id) for tree in trees]
879
886
        # -- make all paths utf8 --
880
887
        paths_utf8 = set()
940
947
            if not all_versioned:
941
948
                raise errors.PathsNotVersionedError(paths)
942
949
        # -- remove redundancy in supplied paths to prevent over-scanning --
943
 
        search_paths = osutils.minimum_path_selection(paths)
944
 
        # sketch:
 
950
        search_paths = set()
 
951
        for path in paths:
 
952
            other_paths = paths.difference(set([path]))
 
953
            if not osutils.is_inside_any(other_paths, path):
 
954
                # this is a top level path, we must check it.
 
955
                search_paths.add(path)
 
956
        # sketch: 
945
957
        # for all search_indexs in each path at or under each element of
946
958
        # search_paths, if the detail is relocated: add the id, and add the
947
959
        # relocated path as one to search if its not searched already. If the
1003
1015
 
1004
1016
    def read_working_inventory(self):
1005
1017
        """Read the working inventory.
1006
 
 
 
1018
        
1007
1019
        This is a meaningless operation for dirstate, but we obey it anyhow.
1008
1020
        """
1009
1021
        return self.inventory
1014
1026
 
1015
1027
        WorkingTree4 supplies revision_trees for any basis tree.
1016
1028
        """
 
1029
        revision_id = osutils.safe_revision_id(revision_id)
1017
1030
        dirstate = self.current_dirstate()
1018
1031
        parent_ids = dirstate.get_parent_ids()
1019
1032
        if revision_id not in parent_ids:
1026
1039
    @needs_tree_write_lock
1027
1040
    def set_last_revision(self, new_revision):
1028
1041
        """Change the last revision in the working tree."""
 
1042
        new_revision = osutils.safe_revision_id(new_revision)
1029
1043
        parents = self.get_parent_ids()
1030
 
        if new_revision in (_mod_revision.NULL_REVISION, None):
1031
 
            if len(parents) >= 2:
1032
 
                raise AssertionError(
1033
 
                    "setting the last parent to none with a pending merge is "
1034
 
                    "unsupported.")
 
1044
        if new_revision in (NULL_REVISION, None):
 
1045
            assert len(parents) < 2, (
 
1046
                "setting the last parent to none with a pending merge is "
 
1047
                "unsupported.")
1035
1048
            self.set_parent_ids([])
1036
1049
        else:
1037
1050
            self.set_parent_ids([new_revision] + parents[1:],
1040
1053
    @needs_tree_write_lock
1041
1054
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
1042
1055
        """Set the parent ids to revision_ids.
1043
 
 
 
1056
        
1044
1057
        See also set_parent_trees. This api will try to retrieve the tree data
1045
1058
        for each element of revision_ids from the trees repository. If you have
1046
1059
        tree data already available, it is more efficient to use
1050
1063
        :param revision_ids: The revision_ids to set as the parent ids of this
1051
1064
            working tree. Any of these may be ghosts.
1052
1065
        """
 
1066
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1053
1067
        trees = []
1054
1068
        for revision_id in revision_ids:
1055
1069
            try:
1078
1092
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
1079
1093
        real_trees = []
1080
1094
        ghosts = []
1081
 
 
1082
 
        parent_ids = [rev_id for rev_id, tree in parents_list]
1083
 
        graph = self.branch.repository.get_graph()
1084
 
        heads = graph.heads(parent_ids)
1085
 
        accepted_revisions = set()
1086
 
 
1087
1095
        # convert absent trees to the null tree, which we convert back to
1088
1096
        # missing on access.
1089
1097
        for rev_id, tree in parents_list:
1090
 
            if len(accepted_revisions) > 0:
1091
 
                # we always accept the first tree
1092
 
                if rev_id in accepted_revisions or rev_id not in heads:
1093
 
                    # We have already included either this tree, or its
1094
 
                    # descendent, so we skip it.
1095
 
                    continue
 
1098
            rev_id = osutils.safe_revision_id(rev_id)
1096
1099
            _mod_revision.check_not_reserved_id(rev_id)
1097
1100
            if tree is not None:
1098
1101
                real_trees.append((rev_id, tree))
1099
1102
            else:
1100
1103
                real_trees.append((rev_id,
1101
 
                    self.branch.repository.revision_tree(
1102
 
                        _mod_revision.NULL_REVISION)))
 
1104
                    self.branch.repository.revision_tree(None)))
1103
1105
                ghosts.append(rev_id)
1104
 
            accepted_revisions.add(rev_id)
1105
1106
        dirstate.set_parent_trees(real_trees, ghosts=ghosts)
1106
1107
        self._make_dirty(reset_inventory=False)
1107
1108
 
1112
1113
        if state._dirblock_state == dirstate.DirState.IN_MEMORY_MODIFIED:
1113
1114
            self._make_dirty(reset_inventory=True)
1114
1115
 
1115
 
    def _sha_from_stat(self, path, stat_result):
1116
 
        """Get a sha digest from the tree's stat cache.
1117
 
 
1118
 
        The default implementation assumes no stat cache is present.
1119
 
 
1120
 
        :param path: The path.
1121
 
        :param stat_result: The stat result being looked up.
1122
 
        """
1123
 
        return self.current_dirstate().sha1_from_stat(path, stat_result)
1124
 
 
1125
1116
    @needs_read_lock
1126
1117
    def supports_tree_reference(self):
1127
1118
        return self._repo_supports_tree_reference
1167
1158
            return
1168
1159
        state = self.current_dirstate()
1169
1160
        state._read_dirblocks_if_needed()
1170
 
        ids_to_unversion = set(file_ids)
 
1161
        ids_to_unversion = set()
 
1162
        for file_id in file_ids:
 
1163
            ids_to_unversion.add(osutils.safe_file_id(file_id))
1171
1164
        paths_to_unversion = set()
1172
1165
        # sketch:
1173
1166
        # check if the root is to be unversioned, if so, assert for now.
1200
1193
                # just forget the whole block.
1201
1194
                entry_index = 0
1202
1195
                while entry_index < len(block[1]):
 
1196
                    # Mark this file id as having been removed
1203
1197
                    entry = block[1][entry_index]
1204
 
                    if entry[1][0][0] in 'ar':
1205
 
                        # don't remove absent or renamed entries
 
1198
                    ids_to_unversion.discard(entry[0][2])
 
1199
                    if (entry[1][0][0] == 'a'
 
1200
                        or not state._make_absent(entry)):
1206
1201
                        entry_index += 1
1207
 
                    else:
1208
 
                        # Mark this file id as having been removed
1209
 
                        ids_to_unversion.discard(entry[0][2])
1210
 
                        if not state._make_absent(entry):
1211
 
                            # The block has not shrunk.
1212
 
                            entry_index += 1
1213
1202
                # go to the next block. (At the moment we dont delete empty
1214
1203
                # dirblocks)
1215
1204
                block_index += 1
1238
1227
            for file_id in file_ids:
1239
1228
                self._inventory.remove_recursive_id(file_id)
1240
1229
 
1241
 
    @needs_tree_write_lock
1242
 
    def rename_one(self, from_rel, to_rel, after=False):
1243
 
        """See WorkingTree.rename_one"""
1244
 
        self.flush()
1245
 
        WorkingTree.rename_one(self, from_rel, to_rel, after)
1246
 
 
1247
 
    @needs_tree_write_lock
1248
 
    def apply_inventory_delta(self, changes):
1249
 
        """See MutableTree.apply_inventory_delta"""
1250
 
        state = self.current_dirstate()
1251
 
        state.update_by_delta(changes)
1252
 
        self._make_dirty(reset_inventory=True)
1253
 
 
1254
 
    def update_basis_by_delta(self, new_revid, delta):
1255
 
        """See MutableTree.update_basis_by_delta."""
1256
 
        if self.last_revision() == new_revid:
1257
 
            raise AssertionError()
1258
 
        self.current_dirstate().update_basis_by_delta(delta, new_revid)
1259
 
 
1260
1230
    @needs_read_lock
1261
1231
    def _validate(self):
1262
1232
        self._dirstate._validate()
1264
1234
    @needs_tree_write_lock
1265
1235
    def _write_inventory(self, inv):
1266
1236
        """Write inventory as the current inventory."""
1267
 
        if self._dirty:
1268
 
            raise AssertionError("attempting to write an inventory when the "
1269
 
                "dirstate is dirty will lose pending changes")
1270
 
        had_inventory = self._inventory is not None
1271
 
        # Setting self._inventory = None forces the dirstate to regenerate the
1272
 
        # working inventory. We do this because self.inventory may be inv, or
1273
 
        # may have been modified, and either case would prevent a clean delta
1274
 
        # being created.
1275
 
        self._inventory = None
1276
 
        # generate a delta,
1277
 
        delta = inv._make_delta(self.inventory)
1278
 
        # and apply it.
1279
 
        self.apply_inventory_delta(delta)
1280
 
        if had_inventory:
 
1237
        assert not self._dirty, "attempting to write an inventory when the dirstate is dirty will cause data loss"
 
1238
        self.current_dirstate().set_state_from_inventory(inv)
 
1239
        self._make_dirty(reset_inventory=False)
 
1240
        if self._inventory is not None:
1281
1241
            self._inventory = inv
1282
1242
        self.flush()
1283
1243
 
1284
1244
 
1285
 
class ContentFilterAwareSHA1Provider(dirstate.SHA1Provider):
1286
 
 
1287
 
    def __init__(self, tree):
1288
 
        self.tree = tree
1289
 
 
1290
 
    def sha1(self, abspath):
1291
 
        """See dirstate.SHA1Provider.sha1()."""
1292
 
        filters = self.tree._content_filter_stack(
1293
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1294
 
        return internal_size_sha_file_byname(abspath, filters)[1]
1295
 
 
1296
 
    def stat_and_sha1(self, abspath):
1297
 
        """See dirstate.SHA1Provider.stat_and_sha1()."""
1298
 
        filters = self.tree._content_filter_stack(
1299
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1300
 
        file_obj = file(abspath, 'rb', 65000)
1301
 
        try:
1302
 
            statvalue = os.fstat(file_obj.fileno())
1303
 
            if filters:
1304
 
                file_obj = filtered_input_file(file_obj, filters)
1305
 
            sha1 = osutils.size_sha_file(file_obj)[1]
1306
 
        finally:
1307
 
            file_obj.close()
1308
 
        return statvalue, sha1
1309
 
 
1310
 
 
1311
 
class ContentFilteringDirStateWorkingTree(DirStateWorkingTree):
1312
 
    """Dirstate working tree that supports content filtering.
1313
 
 
1314
 
    The dirstate holds the hash and size of the canonical form of the file, 
1315
 
    and most methods must return that.
1316
 
    """
1317
 
 
1318
 
    def _file_content_summary(self, path, stat_result):
1319
 
        # This is to support the somewhat obsolete path_content_summary method
1320
 
        # with content filtering: see
1321
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/415508>.
1322
 
        #
1323
 
        # If the dirstate cache is up to date and knows the hash and size,
1324
 
        # return that.
1325
 
        # Otherwise if there are no content filters, return the on-disk size
1326
 
        # and leave the hash blank.
1327
 
        # Otherwise, read and filter the on-disk file and use its size and
1328
 
        # hash.
1329
 
        #
1330
 
        # The dirstate doesn't store the size of the canonical form so we
1331
 
        # can't trust it for content-filtered trees.  We just return None.
1332
 
        dirstate_sha1 = self._dirstate.sha1_from_stat(path, stat_result)
1333
 
        executable = self._is_executable_from_path_and_stat(path, stat_result)
1334
 
        return ('file', None, executable, dirstate_sha1)
1335
 
 
1336
 
 
1337
 
class WorkingTree4(DirStateWorkingTree):
1338
 
    """This is the Format 4 working tree.
1339
 
 
1340
 
    This differs from WorkingTree3 by:
1341
 
     - Having a consolidated internal dirstate, stored in a
1342
 
       randomly-accessible sorted file on disk.
1343
 
     - Not having a regular inventory attribute.  One can be synthesized
1344
 
       on demand but this is expensive and should be avoided.
1345
 
 
1346
 
    This is new in bzr 0.15.
1347
 
    """
1348
 
 
1349
 
 
1350
 
class WorkingTree5(ContentFilteringDirStateWorkingTree):
1351
 
    """This is the Format 5 working tree.
1352
 
 
1353
 
    This differs from WorkingTree4 by:
1354
 
     - Supporting content filtering.
1355
 
 
1356
 
    This is new in bzr 1.11.
1357
 
    """
1358
 
 
1359
 
 
1360
 
class WorkingTree6(ContentFilteringDirStateWorkingTree):
1361
 
    """This is the Format 6 working tree.
1362
 
 
1363
 
    This differs from WorkingTree5 by:
1364
 
     - Supporting a current view that may mask the set of files in a tree
1365
 
       impacted by most user operations.
1366
 
 
1367
 
    This is new in bzr 1.14.
1368
 
    """
1369
 
 
1370
 
    def _make_views(self):
1371
 
        return views.PathBasedViews(self)
1372
 
 
1373
 
 
1374
 
class DirStateWorkingTreeFormat(WorkingTreeFormat3):
1375
 
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
1376
 
                   accelerator_tree=None, hardlink=False):
 
1245
class WorkingTreeFormat4(WorkingTreeFormat3):
 
1246
    """The first consolidated dirstate working tree format.
 
1247
 
 
1248
    This format:
 
1249
        - exists within a metadir controlling .bzr
 
1250
        - includes an explicit version marker for the workingtree control
 
1251
          files, separate from the BzrDir format
 
1252
        - modifies the hash cache format
 
1253
        - is new in bzr 0.15
 
1254
        - uses a LockDir to guard access to it.
 
1255
    """
 
1256
 
 
1257
    upgrade_recommended = False
 
1258
 
 
1259
    def get_format_string(self):
 
1260
        """See WorkingTreeFormat.get_format_string()."""
 
1261
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
 
1262
 
 
1263
    def get_format_description(self):
 
1264
        """See WorkingTreeFormat.get_format_description()."""
 
1265
        return "Working tree format 4"
 
1266
 
 
1267
    def initialize(self, a_bzrdir, revision_id=None):
1377
1268
        """See WorkingTreeFormat.initialize().
1378
1269
 
1379
1270
        :param revision_id: allows creating a working tree at a different
1380
1271
        revision than the branch is at.
1381
 
        :param accelerator_tree: A tree which can be used for retrieving file
1382
 
            contents more quickly than the revision tree, i.e. a workingtree.
1383
 
            The revision tree will be used for cases where accelerator_tree's
1384
 
            content is different.
1385
 
        :param hardlink: If true, hard-link files from accelerator_tree,
1386
 
            where possible.
1387
1272
 
1388
1273
        These trees get an initial random root id, if their repository supports
1389
1274
        rich root data, TREE_ROOT otherwise.
1390
1275
        """
 
1276
        revision_id = osutils.safe_revision_id(revision_id)
1391
1277
        if not isinstance(a_bzrdir.transport, LocalTransport):
1392
1278
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
1393
1279
        transport = a_bzrdir.get_workingtree_transport(self)
1394
1280
        control_files = self._open_control_files(a_bzrdir)
1395
1281
        control_files.create_lock()
1396
1282
        control_files.lock_write()
1397
 
        transport.put_bytes('format', self.get_format_string(),
1398
 
            mode=a_bzrdir._get_file_mode())
1399
 
        if from_branch is not None:
1400
 
            branch = from_branch
1401
 
        else:
1402
 
            branch = a_bzrdir.open_branch()
 
1283
        control_files.put_utf8('format', self.get_format_string())
 
1284
        branch = a_bzrdir.open_branch()
1403
1285
        if revision_id is None:
1404
1286
            revision_id = branch.last_revision()
1405
1287
        local_path = transport.local_abspath('dirstate')
1407
1289
        state = dirstate.DirState.initialize(local_path)
1408
1290
        state.unlock()
1409
1291
        del state
1410
 
        wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
1292
        wt = WorkingTree4(a_bzrdir.root_transport.local_abspath('.'),
1411
1293
                         branch,
1412
1294
                         _format=self,
1413
1295
                         _bzrdir=a_bzrdir,
1415
1297
        wt._new_tree()
1416
1298
        wt.lock_tree_write()
1417
1299
        try:
1418
 
            self._init_custom_control_files(wt)
1419
 
            if revision_id in (None, _mod_revision.NULL_REVISION):
 
1300
            if revision_id in (None, NULL_REVISION):
1420
1301
                if branch.repository.supports_rich_root():
1421
1302
                    wt._set_root_id(generate_ids.gen_root_id())
1422
1303
                else:
1423
1304
                    wt._set_root_id(ROOT_ID)
1424
1305
                wt.flush()
1425
 
            basis = None
1426
 
            # frequently, we will get here due to branching.  The accelerator
1427
 
            # tree will be the tree from the branch, so the desired basis
1428
 
            # tree will often be a parent of the accelerator tree.
1429
 
            if accelerator_tree is not None:
1430
 
                try:
1431
 
                    basis = accelerator_tree.revision_tree(revision_id)
1432
 
                except errors.NoSuchRevision:
1433
 
                    pass
1434
 
            if basis is None:
1435
 
                basis = branch.repository.revision_tree(revision_id)
1436
 
            if revision_id == _mod_revision.NULL_REVISION:
1437
 
                parents_list = []
1438
 
            else:
1439
 
                parents_list = [(revision_id, basis)]
 
1306
            wt.set_last_revision(revision_id)
 
1307
            wt.flush()
 
1308
            basis = wt.basis_tree()
1440
1309
            basis.lock_read()
1441
 
            try:
1442
 
                wt.set_parent_trees(parents_list, allow_leftmost_as_ghost=True)
 
1310
            # if the basis has a root id we have to use that; otherwise we use
 
1311
            # a new random one
 
1312
            basis_root_id = basis.get_root_id()
 
1313
            if basis_root_id is not None:
 
1314
                wt._set_root_id(basis_root_id)
1443
1315
                wt.flush()
1444
 
                # if the basis has a root id we have to use that; otherwise we
1445
 
                # use a new random one
1446
 
                basis_root_id = basis.get_root_id()
1447
 
                if basis_root_id is not None:
1448
 
                    wt._set_root_id(basis_root_id)
1449
 
                    wt.flush()
1450
 
                if wt.supports_content_filtering():
1451
 
                    # The original tree may not have the same content filters
1452
 
                    # applied so we can't safely build the inventory delta from
1453
 
                    # the source tree.
1454
 
                    delta_from_tree = False
1455
 
                else:
1456
 
                    delta_from_tree = True
1457
 
                # delta_from_tree is safe even for DirStateRevisionTrees,
1458
 
                # because wt4.apply_inventory_delta does not mutate the input
1459
 
                # inventory entries.
1460
 
                transform.build_tree(basis, wt, accelerator_tree,
1461
 
                                     hardlink=hardlink,
1462
 
                                     delta_from_tree=delta_from_tree)
1463
 
            finally:
1464
 
                basis.unlock()
 
1316
            transform.build_tree(basis, wt)
 
1317
            basis.unlock()
1465
1318
        finally:
1466
1319
            control_files.unlock()
1467
1320
            wt.unlock()
1468
1321
        return wt
1469
1322
 
1470
 
    def _init_custom_control_files(self, wt):
1471
 
        """Subclasses with custom control files should override this method.
1472
 
 
1473
 
        The working tree and control files are locked for writing when this
1474
 
        method is called.
1475
 
 
1476
 
        :param wt: the WorkingTree object
1477
 
        """
1478
 
 
1479
1323
    def _open(self, a_bzrdir, control_files):
1480
1324
        """Open the tree itself.
1481
1325
 
1482
1326
        :param a_bzrdir: the dir for the tree.
1483
1327
        :param control_files: the control files for the tree.
1484
1328
        """
1485
 
        return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
1329
        return WorkingTree4(a_bzrdir.root_transport.local_abspath('.'),
1486
1330
                           branch=a_bzrdir.open_branch(),
1487
1331
                           _format=self,
1488
1332
                           _bzrdir=a_bzrdir,
1489
1333
                           _control_files=control_files)
1490
1334
 
1491
1335
    def __get_matchingbzrdir(self):
1492
 
        return self._get_matchingbzrdir()
1493
 
 
1494
 
    def _get_matchingbzrdir(self):
1495
 
        """Overrideable method to get a bzrdir for testing."""
1496
1336
        # please test against something that will let us do tree references
1497
1337
        return bzrdir.format_registry.make_bzrdir(
1498
1338
            'dirstate-with-subtree')
1500
1340
    _matchingbzrdir = property(__get_matchingbzrdir)
1501
1341
 
1502
1342
 
1503
 
class WorkingTreeFormat4(DirStateWorkingTreeFormat):
1504
 
    """The first consolidated dirstate working tree format.
1505
 
 
1506
 
    This format:
1507
 
        - exists within a metadir controlling .bzr
1508
 
        - includes an explicit version marker for the workingtree control
1509
 
          files, separate from the BzrDir format
1510
 
        - modifies the hash cache format
1511
 
        - is new in bzr 0.15
1512
 
        - uses a LockDir to guard access to it.
1513
 
    """
1514
 
 
1515
 
    upgrade_recommended = False
1516
 
 
1517
 
    _tree_class = WorkingTree4
1518
 
 
1519
 
    def get_format_string(self):
1520
 
        """See WorkingTreeFormat.get_format_string()."""
1521
 
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
1522
 
 
1523
 
    def get_format_description(self):
1524
 
        """See WorkingTreeFormat.get_format_description()."""
1525
 
        return "Working tree format 4"
1526
 
 
1527
 
 
1528
 
class WorkingTreeFormat5(DirStateWorkingTreeFormat):
1529
 
    """WorkingTree format supporting content filtering.
1530
 
    """
1531
 
 
1532
 
    upgrade_recommended = False
1533
 
 
1534
 
    _tree_class = WorkingTree5
1535
 
 
1536
 
    def get_format_string(self):
1537
 
        """See WorkingTreeFormat.get_format_string()."""
1538
 
        return "Bazaar Working Tree Format 5 (bzr 1.11)\n"
1539
 
 
1540
 
    def get_format_description(self):
1541
 
        """See WorkingTreeFormat.get_format_description()."""
1542
 
        return "Working tree format 5"
1543
 
 
1544
 
    def supports_content_filtering(self):
1545
 
        return True
1546
 
 
1547
 
 
1548
 
class WorkingTreeFormat6(DirStateWorkingTreeFormat):
1549
 
    """WorkingTree format supporting views.
1550
 
    """
1551
 
 
1552
 
    upgrade_recommended = False
1553
 
 
1554
 
    _tree_class = WorkingTree6
1555
 
 
1556
 
    def get_format_string(self):
1557
 
        """See WorkingTreeFormat.get_format_string()."""
1558
 
        return "Bazaar Working Tree Format 6 (bzr 1.14)\n"
1559
 
 
1560
 
    def get_format_description(self):
1561
 
        """See WorkingTreeFormat.get_format_description()."""
1562
 
        return "Working tree format 6"
1563
 
 
1564
 
    def _init_custom_control_files(self, wt):
1565
 
        """Subclasses with custom control files should override this method."""
1566
 
        wt._transport.put_bytes('views', '', mode=wt.bzrdir._get_file_mode())
1567
 
 
1568
 
    def supports_content_filtering(self):
1569
 
        return True
1570
 
 
1571
 
    def supports_views(self):
1572
 
        return True
1573
 
 
1574
 
 
1575
1343
class DirStateRevisionTree(Tree):
1576
 
    """A revision tree pulling the inventory from a dirstate.
1577
 
    
1578
 
    Note that this is one of the historical (ie revision) trees cached in the
1579
 
    dirstate for easy access, not the workingtree.
1580
 
    """
 
1344
    """A revision tree pulling the inventory from a dirstate."""
1581
1345
 
1582
1346
    def __init__(self, dirstate, revision_id, repository):
1583
1347
        self._dirstate = dirstate
1584
 
        self._revision_id = revision_id
 
1348
        self._revision_id = osutils.safe_revision_id(revision_id)
1585
1349
        self._repository = repository
1586
1350
        self._inventory = None
1587
1351
        self._locked = 0
1588
1352
        self._dirstate_locked = False
1589
 
        self._repo_supports_tree_reference = getattr(
1590
 
            repository._format, "supports_tree_reference",
1591
 
            False)
1592
1353
 
1593
1354
    def __repr__(self):
1594
1355
        return "<%s of %s in %s>" % \
1597
1358
    def annotate_iter(self, file_id,
1598
1359
                      default_revision=_mod_revision.CURRENT_REVISION):
1599
1360
        """See Tree.annotate_iter"""
1600
 
        text_key = (file_id, self.inventory[file_id].revision)
1601
 
        annotations = self._repository.texts.annotate(text_key)
1602
 
        return [(key[-1], line) for (key, line) in annotations]
 
1361
        w = self._get_weave(file_id)
 
1362
        return w.annotate_iter(self.inventory[file_id].revision)
1603
1363
 
1604
1364
    def _get_ancestors(self, default_revision):
1605
1365
        return set(self._repository.get_ancestry(self._revision_id,
1626
1386
    def get_root_id(self):
1627
1387
        return self.path2id('')
1628
1388
 
1629
 
    def id2path(self, file_id):
1630
 
        "Convert a file-id to a path."
1631
 
        entry = self._get_entry(file_id=file_id)
1632
 
        if entry == (None, None):
1633
 
            raise errors.NoSuchId(tree=self, file_id=file_id)
1634
 
        path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
1635
 
        return path_utf8.decode('utf8')
1636
 
 
1637
 
    def iter_references(self):
1638
 
        if not self._repo_supports_tree_reference:
1639
 
            # When the repo doesn't support references, we will have nothing to
1640
 
            # return
1641
 
            return iter([])
1642
 
        # Otherwise, fall back to the default implementation
1643
 
        return super(DirStateRevisionTree, self).iter_references()
1644
 
 
1645
1389
    def _get_parent_index(self):
1646
1390
        """Return the index in the dirstate referenced by this tree."""
1647
1391
        return self._dirstate.get_parent_ids().index(self._revision_id) + 1
1652
1396
        If either file_id or path is supplied, it is used as the key to lookup.
1653
1397
        If both are supplied, the fastest lookup is used, and an error is
1654
1398
        raised if they do not both point at the same row.
1655
 
 
 
1399
        
1656
1400
        :param file_id: An optional unicode file_id to be looked up.
1657
1401
        :param path: An optional unicode path to be looked up.
1658
1402
        :return: The dirstate row tuple for path/file_id, or (None, None)
1659
1403
        """
1660
1404
        if file_id is None and path is None:
1661
1405
            raise errors.BzrError('must supply file_id or path')
 
1406
        file_id = osutils.safe_file_id(file_id)
1662
1407
        if path is not None:
1663
1408
            path = path.encode('utf8')
1664
1409
        parent_index = self._get_parent_index()
1672
1417
 
1673
1418
        This is relatively expensive: we have to walk the entire dirstate.
1674
1419
        """
1675
 
        if not self._locked:
1676
 
            raise AssertionError(
1677
 
                'cannot generate inventory of an unlocked '
1678
 
                'dirstate revision tree')
 
1420
        assert self._locked, 'cannot generate inventory of an unlocked '\
 
1421
            'dirstate revision tree'
1679
1422
        # separate call for profiling - makes it clear where the costs are.
1680
1423
        self._dirstate._read_dirblocks_if_needed()
1681
 
        if self._revision_id not in self._dirstate.get_parent_ids():
1682
 
            raise AssertionError(
1683
 
                'parent %s has disappeared from %s' % (
1684
 
                self._revision_id, self._dirstate.get_parent_ids()))
 
1424
        assert self._revision_id in self._dirstate.get_parent_ids(), \
 
1425
            'parent %s has disappeared from %s' % (
 
1426
            self._revision_id, self._dirstate.get_parent_ids())
1685
1427
        parent_index = self._dirstate.get_parent_ids().index(self._revision_id) + 1
1686
1428
        # This is identical now to the WorkingTree _generate_inventory except
1687
1429
        # for the tree index use.
1688
1430
        root_key, current_entry = self._dirstate._get_entry(parent_index, path_utf8='')
1689
1431
        current_id = root_key[2]
1690
 
        if current_entry[parent_index][0] != 'd':
1691
 
            raise AssertionError()
 
1432
        assert current_entry[parent_index][0] == 'd'
1692
1433
        inv = Inventory(root_id=current_id, revision_id=self._revision_id)
1693
1434
        inv.root.revision = current_entry[parent_index][4]
1694
1435
        # Turn some things into local variables
1734
1475
                    raise AssertionError("cannot convert entry %r into an InventoryEntry"
1735
1476
                            % entry)
1736
1477
                # These checks cost us around 40ms on a 55k entry tree
1737
 
                if file_id in inv_byid:
1738
 
                    raise AssertionError('file_id %s already in'
1739
 
                        ' inventory as %s' % (file_id, inv_byid[file_id]))
1740
 
                if name_unicode in parent_ie.children:
1741
 
                    raise AssertionError('name %r already in parent'
1742
 
                        % (name_unicode,))
 
1478
                assert file_id not in inv_byid
 
1479
                assert name_unicode not in parent_ie.children
1743
1480
                inv_byid[file_id] = inv_entry
1744
1481
                parent_ie.children[name_unicode] = inv_entry
1745
1482
        self._inventory = inv
1755
1492
            return None
1756
1493
        parent_index = self._get_parent_index()
1757
1494
        last_changed_revision = entry[1][parent_index][4]
1758
 
        try:
1759
 
            rev = self._repository.get_revision(last_changed_revision)
1760
 
        except errors.NoSuchRevision:
1761
 
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
1762
 
        return rev.timestamp
 
1495
        return self._repository.get_revision(last_changed_revision).timestamp
1763
1496
 
1764
1497
    def get_file_sha1(self, file_id, path=None, stat_value=None):
1765
1498
        entry = self._get_entry(file_id=file_id, path=path)
1769
1502
            return parent_details[1]
1770
1503
        return None
1771
1504
 
1772
 
    def get_file(self, file_id, path=None):
 
1505
    @symbol_versioning.deprecated_method(symbol_versioning.zero_ninety)
 
1506
    def get_weave(self, file_id):
 
1507
        return self._get_weave(file_id)
 
1508
 
 
1509
    def _get_weave(self, file_id):
 
1510
        return self._repository.weave_store.get_weave(file_id,
 
1511
                self._repository.get_transaction())
 
1512
 
 
1513
    def get_file(self, file_id):
1773
1514
        return StringIO(self.get_file_text(file_id))
1774
1515
 
 
1516
    def get_file_lines(self, file_id):
 
1517
        ie = self.inventory[file_id]
 
1518
        return self._get_weave(file_id).get_lines(ie.revision)
 
1519
 
1775
1520
    def get_file_size(self, file_id):
1776
 
        """See Tree.get_file_size"""
1777
1521
        return self.inventory[file_id].text_size
1778
1522
 
1779
 
    def get_file_text(self, file_id, path=None):
1780
 
        _, content = list(self.iter_files_bytes([(file_id, None)]))[0]
1781
 
        return ''.join(content)
 
1523
    def get_file_text(self, file_id):
 
1524
        return ''.join(self.get_file_lines(file_id))
1782
1525
 
1783
1526
    def get_reference_revision(self, file_id, path=None):
1784
1527
        return self.inventory[file_id].reference_revision
1803
1546
        if entry[1][parent_index][0] != 'l':
1804
1547
            return None
1805
1548
        else:
1806
 
            target = entry[1][parent_index][1]
1807
 
            target = target.decode('utf8')
1808
 
            return target
 
1549
            # At present, none of the tree implementations supports non-ascii
 
1550
            # symlink targets. So we will just assume that the dirstate path is
 
1551
            # correct.
 
1552
            return entry[1][parent_index][1]
1809
1553
 
1810
1554
    def get_revision_id(self):
1811
1555
        """Return the revision id for this tree."""
1829
1573
        return bool(self.path2id(filename))
1830
1574
 
1831
1575
    def kind(self, file_id):
1832
 
        entry = self._get_entry(file_id=file_id)[1]
1833
 
        if entry is None:
1834
 
            raise errors.NoSuchId(tree=self, file_id=file_id)
1835
 
        return dirstate.DirState._minikind_to_kind[entry[1][0]]
1836
 
 
1837
 
    def stored_kind(self, file_id):
1838
 
        """See Tree.stored_kind"""
1839
 
        return self.kind(file_id)
1840
 
 
1841
 
    def path_content_summary(self, path):
1842
 
        """See Tree.path_content_summary."""
1843
 
        id = self.inventory.path2id(path)
1844
 
        if id is None:
1845
 
            return ('missing', None, None, None)
1846
 
        entry = self._inventory[id]
1847
 
        kind = entry.kind
1848
 
        if kind == 'file':
1849
 
            return (kind, entry.text_size, entry.executable, entry.text_sha1)
1850
 
        elif kind == 'symlink':
1851
 
            return (kind, None, None, entry.symlink_target)
1852
 
        else:
1853
 
            return (kind, None, None, None)
 
1576
        return self.inventory[file_id].kind
1854
1577
 
1855
1578
    def is_executable(self, file_id, path=None):
1856
1579
        ie = self.inventory[file_id]
1858
1581
            return None
1859
1582
        return ie.executable
1860
1583
 
1861
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
1584
    def list_files(self, include_root=False):
1862
1585
        # We use a standard implementation, because DirStateRevisionTree is
1863
1586
        # dealing with one of the parents of the current state
1864
1587
        inv = self._get_inventory()
1865
 
        if from_dir is None:
1866
 
            from_dir_id = None
1867
 
        else:
1868
 
            from_dir_id = inv.path2id(from_dir)
1869
 
            if from_dir_id is None:
1870
 
                # Directory not versioned
1871
 
                return
1872
 
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
1873
 
        if inv.root is not None and not include_root and from_dir is None:
 
1588
        entries = inv.iter_entries()
 
1589
        if self.inventory.root is not None and not include_root:
1874
1590
            entries.next()
1875
1591
        for path, entry in entries:
1876
1592
            yield path, 'V', entry.kind, entry.file_id, entry
1909
1625
                self._dirstate_locked = False
1910
1626
            self._repository.unlock()
1911
1627
 
1912
 
    @needs_read_lock
1913
 
    def supports_tree_reference(self):
1914
 
        return self._repo_supports_tree_reference
1915
 
 
1916
1628
    def walkdirs(self, prefix=""):
1917
1629
        # TODO: jam 20070215 This is the lazy way by using the RevisionTree
1918
 
        # implementation based on an inventory.
 
1630
        # implementation based on an inventory.  
1919
1631
        # This should be cleaned up to use the much faster Dirstate code
1920
1632
        # So for now, we just build up the parent inventory, and extract
1921
1633
        # it the same way RevisionTree does.
1950
1662
 
1951
1663
class InterDirStateTree(InterTree):
1952
1664
    """Fast path optimiser for changes_from with dirstate trees.
1953
 
 
1954
 
    This is used only when both trees are in the dirstate working file, and
1955
 
    the source is any parent within the dirstate, and the destination is
 
1665
    
 
1666
    This is used only when both trees are in the dirstate working file, and 
 
1667
    the source is any parent within the dirstate, and the destination is 
1956
1668
    the current working tree of the same dirstate.
1957
1669
    """
1958
1670
    # this could be generalized to allow comparisons between any trees in the
1971
1683
        target.set_parent_ids([revid])
1972
1684
        return target.basis_tree(), target
1973
1685
 
1974
 
    @classmethod
1975
 
    def make_source_parent_tree_python_dirstate(klass, test_case, source, target):
1976
 
        result = klass.make_source_parent_tree(source, target)
1977
 
        result[1]._iter_changes = dirstate.ProcessEntryPython
1978
 
        return result
1979
 
 
1980
 
    @classmethod
1981
 
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source,
1982
 
                                                  target):
1983
 
        from bzrlib.tests.test__dirstate_helpers import \
1984
 
            compiled_dirstate_helpers_feature
1985
 
        test_case.requireFeature(compiled_dirstate_helpers_feature)
1986
 
        from bzrlib._dirstate_helpers_pyx import ProcessEntryC
1987
 
        result = klass.make_source_parent_tree(source, target)
1988
 
        result[1]._iter_changes = ProcessEntryC
1989
 
        return result
1990
 
 
1991
1686
    _matching_from_tree_format = WorkingTreeFormat4()
1992
1687
    _matching_to_tree_format = WorkingTreeFormat4()
1993
 
 
1994
 
    @classmethod
1995
 
    def _test_mutable_trees_to_test_trees(klass, test_case, source, target):
1996
 
        # This method shouldn't be called, because we have python and C
1997
 
        # specific flavours.
1998
 
        raise NotImplementedError
1999
 
 
2000
 
    def iter_changes(self, include_unchanged=False,
 
1688
    _test_mutable_trees_to_test_trees = make_source_parent_tree
 
1689
 
 
1690
    def _iter_changes(self, include_unchanged=False,
2001
1691
                      specific_files=None, pb=None, extra_trees=[],
2002
1692
                      require_versioned=True, want_unversioned=False):
2003
1693
        """Return the changes from source to target.
2004
1694
 
2005
 
        :return: An iterator that yields tuples. See InterTree.iter_changes
 
1695
        :return: An iterator that yields tuples. See InterTree._iter_changes
2006
1696
            for details.
2007
1697
        :param specific_files: An optional list of file paths to restrict the
2008
1698
            comparison to. When mapping filenames to ids, all matches in all
2019
1709
            output. An unversioned file is defined as one with (False, False)
2020
1710
            for the versioned pair.
2021
1711
        """
 
1712
        utf8_decode = cache_utf8._utf8_decode
 
1713
        _minikind_to_kind = dirstate.DirState._minikind_to_kind
 
1714
        cmp_by_dirs = dirstate.cmp_by_dirs
 
1715
        # NB: show_status depends on being able to pass in non-versioned files
 
1716
        # and report them as unknown
2022
1717
        # TODO: handle extra trees in the dirstate.
2023
 
        if (extra_trees or specific_files == []):
 
1718
        # TODO: handle comparisons as an empty tree as a different special
 
1719
        # case? mbp 20070226
 
1720
        if extra_trees or (self.source._revision_id == NULL_REVISION):
2024
1721
            # we can't fast-path these cases (yet)
2025
 
            return super(InterDirStateTree, self).iter_changes(
 
1722
            for f in super(InterDirStateTree, self)._iter_changes(
2026
1723
                include_unchanged, specific_files, pb, extra_trees,
2027
 
                require_versioned, want_unversioned=want_unversioned)
 
1724
                require_versioned, want_unversioned=want_unversioned):
 
1725
                yield f
 
1726
            return
2028
1727
        parent_ids = self.target.get_parent_ids()
2029
 
        if not (self.source._revision_id in parent_ids
2030
 
                or self.source._revision_id == _mod_revision.NULL_REVISION):
2031
 
            raise AssertionError(
2032
 
                "revision {%s} is not stored in {%s}, but %s "
2033
 
                "can only be used for trees stored in the dirstate"
2034
 
                % (self.source._revision_id, self.target, self.iter_changes))
 
1728
        assert (self.source._revision_id in parent_ids), \
 
1729
                "revision {%s} is not stored in {%s}, but %s " \
 
1730
                "can only be used for trees stored in the dirstate" \
 
1731
                % (self.source._revision_id, self.target, self._iter_changes)
2035
1732
        target_index = 0
2036
 
        if self.source._revision_id == _mod_revision.NULL_REVISION:
 
1733
        if self.source._revision_id == NULL_REVISION:
2037
1734
            source_index = None
2038
1735
            indices = (target_index,)
2039
1736
        else:
2040
 
            if not (self.source._revision_id in parent_ids):
2041
 
                raise AssertionError(
2042
 
                    "Failure: source._revision_id: %s not in target.parent_ids(%s)" % (
2043
 
                    self.source._revision_id, parent_ids))
 
1737
            assert (self.source._revision_id in parent_ids), \
 
1738
                "Failure: source._revision_id: %s not in target.parent_ids(%s)" % (
 
1739
                self.source._revision_id, parent_ids)
2044
1740
            source_index = 1 + parent_ids.index(self.source._revision_id)
2045
 
            indices = (source_index, target_index)
 
1741
            indices = (source_index,target_index)
2046
1742
        # -- make all specific_files utf8 --
2047
1743
        if specific_files:
2048
1744
            specific_files_utf8 = set()
2049
1745
            for path in specific_files:
2050
 
                # Note, if there are many specific files, using cache_utf8
2051
 
                # would be good here.
2052
1746
                specific_files_utf8.add(path.encode('utf8'))
2053
1747
            specific_files = specific_files_utf8
2054
1748
        else:
2055
1749
            specific_files = set([''])
2056
1750
        # -- specific_files is now a utf8 path set --
2057
 
 
2058
1751
        # -- get the state object and prepare it.
2059
1752
        state = self.target.current_dirstate()
2060
1753
        state._read_dirblocks_if_needed()
 
1754
        def _entries_for_path(path):
 
1755
            """Return a list with all the entries that match path for all ids.
 
1756
            """
 
1757
            dirname, basename = os.path.split(path)
 
1758
            key = (dirname, basename, '')
 
1759
            block_index, present = state._find_block_index_from_key(key)
 
1760
            if not present:
 
1761
                # the block which should contain path is absent.
 
1762
                return []
 
1763
            result = []
 
1764
            block = state._dirblocks[block_index][1]
 
1765
            entry_index, _ = state._find_entry_index(key, block)
 
1766
            # we may need to look at multiple entries at this path: walk while the specific_files match.
 
1767
            while (entry_index < len(block) and
 
1768
                block[entry_index][0][0:2] == key[0:2]):
 
1769
                result.append(block[entry_index])
 
1770
                entry_index += 1
 
1771
            return result
2061
1772
        if require_versioned:
2062
1773
            # -- check all supplied paths are versioned in a search tree. --
2063
 
            not_versioned = []
 
1774
            all_versioned = True
2064
1775
            for path in specific_files:
2065
 
                path_entries = state._entries_for_path(path)
 
1776
                path_entries = _entries_for_path(path)
2066
1777
                if not path_entries:
2067
1778
                    # this specified path is not present at all: error
2068
 
                    not_versioned.append(path)
2069
 
                    continue
 
1779
                    all_versioned = False
 
1780
                    break
2070
1781
                found_versioned = False
2071
1782
                # for each id at this path
2072
1783
                for entry in path_entries:
2079
1790
                if not found_versioned:
2080
1791
                    # none of the indexes was not 'absent' at all ids for this
2081
1792
                    # path.
2082
 
                    not_versioned.append(path)
2083
 
            if len(not_versioned) > 0:
2084
 
                raise errors.PathsNotVersionedError(not_versioned)
 
1793
                    all_versioned = False
 
1794
                    break
 
1795
            if not all_versioned:
 
1796
                raise errors.PathsNotVersionedError(specific_files)
2085
1797
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
2086
 
        search_specific_files = osutils.minimum_path_selection(specific_files)
 
1798
        search_specific_files = set()
 
1799
        for path in specific_files:
 
1800
            other_specific_files = specific_files.difference(set([path]))
 
1801
            if not osutils.is_inside_any(other_specific_files, path):
 
1802
                # this is a top level path, we must check it.
 
1803
                search_specific_files.add(path)
 
1804
        # sketch: 
 
1805
        # compare source_index and target_index at or under each element of search_specific_files.
 
1806
        # follow the following comparison table. Note that we only want to do diff operations when
 
1807
        # the target is fdl because thats when the walkdirs logic will have exposed the pathinfo 
 
1808
        # for the target.
 
1809
        # cases:
 
1810
        # 
 
1811
        # Source | Target | disk | action
 
1812
        #   r    | fdlt   |      | add source to search, add id path move and perform
 
1813
        #        |        |      | diff check on source-target
 
1814
        #   r    | fdlt   |  a   | dangling file that was present in the basis. 
 
1815
        #        |        |      | ???
 
1816
        #   r    |  a     |      | add source to search
 
1817
        #   r    |  a     |  a   | 
 
1818
        #   r    |  r     |      | this path is present in a non-examined tree, skip.
 
1819
        #   r    |  r     |  a   | this path is present in a non-examined tree, skip.
 
1820
        #   a    | fdlt   |      | add new id
 
1821
        #   a    | fdlt   |  a   | dangling locally added file, skip
 
1822
        #   a    |  a     |      | not present in either tree, skip
 
1823
        #   a    |  a     |  a   | not present in any tree, skip
 
1824
        #   a    |  r     |      | not present in either tree at this path, skip as it
 
1825
        #        |        |      | may not be selected by the users list of paths.
 
1826
        #   a    |  r     |  a   | not present in either tree at this path, skip as it
 
1827
        #        |        |      | may not be selected by the users list of paths.
 
1828
        #  fdlt  | fdlt   |      | content in both: diff them
 
1829
        #  fdlt  | fdlt   |  a   | deleted locally, but not unversioned - show as deleted ?
 
1830
        #  fdlt  |  a     |      | unversioned: output deleted id for now
 
1831
        #  fdlt  |  a     |  a   | unversioned and deleted: output deleted id
 
1832
        #  fdlt  |  r     |      | relocated in this tree, so add target to search.
 
1833
        #        |        |      | Dont diff, we will see an r,fd; pair when we reach
 
1834
        #        |        |      | this id at the other path.
 
1835
        #  fdlt  |  r     |  a   | relocated in this tree, so add target to search.
 
1836
        #        |        |      | Dont diff, we will see an r,fd; pair when we reach
 
1837
        #        |        |      | this id at the other path.
 
1838
 
 
1839
        # for all search_indexs in each path at or under each element of
 
1840
        # search_specific_files, if the detail is relocated: add the id, and add the
 
1841
        # relocated path as one to search if its not searched already. If the
 
1842
        # detail is not relocated, add the id.
 
1843
        searched_specific_files = set()
 
1844
        NULL_PARENT_DETAILS = dirstate.DirState.NULL_PARENT_DETAILS
 
1845
        # Using a list so that we can access the values and change them in
 
1846
        # nested scope. Each one is [path, file_id, entry]
 
1847
        last_source_parent = [None, None]
 
1848
        last_target_parent = [None, None]
2087
1849
 
2088
1850
        use_filesystem_for_exec = (sys.platform != 'win32')
2089
 
        iter_changes = self.target._iter_changes(include_unchanged,
2090
 
            use_filesystem_for_exec, search_specific_files, state,
2091
 
            source_index, target_index, want_unversioned, self.target)
2092
 
        return iter_changes.iter_changes()
 
1851
 
 
1852
        # Just a sentry, so that _process_entry can say that this
 
1853
        # record is handled, but isn't interesting to process (unchanged)
 
1854
        uninteresting = object()
 
1855
 
 
1856
 
 
1857
        old_dirname_to_file_id = {}
 
1858
        new_dirname_to_file_id = {}
 
1859
        # TODO: jam 20070516 - Avoid the _get_entry lookup overhead by
 
1860
        #       keeping a cache of directories that we have seen.
 
1861
 
 
1862
        def _process_entry(entry, path_info):
 
1863
            """Compare an entry and real disk to generate delta information.
 
1864
 
 
1865
            :param path_info: top_relpath, basename, kind, lstat, abspath for
 
1866
                the path of entry. If None, then the path is considered absent.
 
1867
                (Perhaps we should pass in a concrete entry for this ?)
 
1868
                Basename is returned as a utf8 string because we expect this
 
1869
                tuple will be ignored, and don't want to take the time to
 
1870
                decode.
 
1871
            :return: None if these don't match
 
1872
                     A tuple of information about the change, or
 
1873
                     the object 'uninteresting' if these match, but are
 
1874
                     basically identical.
 
1875
            """
 
1876
            if source_index is None:
 
1877
                source_details = NULL_PARENT_DETAILS
 
1878
            else:
 
1879
                source_details = entry[1][source_index]
 
1880
            target_details = entry[1][target_index]
 
1881
            target_minikind = target_details[0]
 
1882
            if path_info is not None and target_minikind in 'fdlt':
 
1883
                assert target_index == 0
 
1884
                link_or_sha1 = state.update_entry(entry, abspath=path_info[4],
 
1885
                                                  stat_value=path_info[3])
 
1886
                # The entry may have been modified by update_entry
 
1887
                target_details = entry[1][target_index]
 
1888
                target_minikind = target_details[0]
 
1889
            else:
 
1890
                link_or_sha1 = None
 
1891
            file_id = entry[0][2]
 
1892
            source_minikind = source_details[0]
 
1893
            if source_minikind in 'fdltr' and target_minikind in 'fdlt':
 
1894
                # claimed content in both: diff
 
1895
                #   r    | fdlt   |      | add source to search, add id path move and perform
 
1896
                #        |        |      | diff check on source-target
 
1897
                #   r    | fdlt   |  a   | dangling file that was present in the basis.
 
1898
                #        |        |      | ???
 
1899
                if source_minikind in 'r':
 
1900
                    # add the source to the search path to find any children it
 
1901
                    # has.  TODO ? : only add if it is a container ?
 
1902
                    if not osutils.is_inside_any(searched_specific_files,
 
1903
                                                 source_details[1]):
 
1904
                        search_specific_files.add(source_details[1])
 
1905
                    # generate the old path; this is needed for stating later
 
1906
                    # as well.
 
1907
                    old_path = source_details[1]
 
1908
                    old_dirname, old_basename = os.path.split(old_path)
 
1909
                    path = pathjoin(entry[0][0], entry[0][1])
 
1910
                    old_entry = state._get_entry(source_index,
 
1911
                                                 path_utf8=old_path)
 
1912
                    # update the source details variable to be the real
 
1913
                    # location.
 
1914
                    source_details = old_entry[1][source_index]
 
1915
                    source_minikind = source_details[0]
 
1916
                else:
 
1917
                    old_dirname = entry[0][0]
 
1918
                    old_basename = entry[0][1]
 
1919
                    old_path = path = None
 
1920
                if path_info is None:
 
1921
                    # the file is missing on disk, show as removed.
 
1922
                    content_change = True
 
1923
                    target_kind = None
 
1924
                    target_exec = False
 
1925
                else:
 
1926
                    # source and target are both versioned and disk file is present.
 
1927
                    target_kind = path_info[2]
 
1928
                    if target_kind == 'directory':
 
1929
                        if path is None:
 
1930
                            old_path = path = pathjoin(old_dirname, old_basename)
 
1931
                        new_dirname_to_file_id[path] = file_id
 
1932
                        if source_minikind != 'd':
 
1933
                            content_change = True
 
1934
                        else:
 
1935
                            # directories have no fingerprint
 
1936
                            content_change = False
 
1937
                        target_exec = False
 
1938
                    elif target_kind == 'file':
 
1939
                        if source_minikind != 'f':
 
1940
                            content_change = True
 
1941
                        else:
 
1942
                            # We could check the size, but we already have the
 
1943
                            # sha1 hash.
 
1944
                            content_change = (link_or_sha1 != source_details[1])
 
1945
                        # Target details is updated at update_entry time
 
1946
                        if use_filesystem_for_exec:
 
1947
                            # We don't need S_ISREG here, because we are sure
 
1948
                            # we are dealing with a file.
 
1949
                            target_exec = bool(stat.S_IEXEC & path_info[3].st_mode)
 
1950
                        else:
 
1951
                            target_exec = target_details[3]
 
1952
                    elif target_kind == 'symlink':
 
1953
                        if source_minikind != 'l':
 
1954
                            content_change = True
 
1955
                        else:
 
1956
                            content_change = (link_or_sha1 != source_details[1])
 
1957
                        target_exec = False
 
1958
                    elif target_kind == 'tree-reference':
 
1959
                        if source_minikind != 't':
 
1960
                            content_change = True
 
1961
                        else:
 
1962
                            content_change = False
 
1963
                        target_exec = False
 
1964
                    else:
 
1965
                        raise Exception, "unknown kind %s" % path_info[2]
 
1966
                if source_minikind == 'd':
 
1967
                    if path is None:
 
1968
                        old_path = path = pathjoin(old_dirname, old_basename)
 
1969
                    old_dirname_to_file_id[old_path] = file_id
 
1970
                # parent id is the entry for the path in the target tree
 
1971
                if old_dirname == last_source_parent[0]:
 
1972
                    source_parent_id = last_source_parent[1]
 
1973
                else:
 
1974
                    try:
 
1975
                        source_parent_id = old_dirname_to_file_id[old_dirname]
 
1976
                    except KeyError:
 
1977
                        source_parent_entry = state._get_entry(source_index,
 
1978
                                                               path_utf8=old_dirname)
 
1979
                        source_parent_id = source_parent_entry[0][2]
 
1980
                    if source_parent_id == entry[0][2]:
 
1981
                        # This is the root, so the parent is None
 
1982
                        source_parent_id = None
 
1983
                    else:
 
1984
                        last_source_parent[0] = old_dirname
 
1985
                        last_source_parent[1] = source_parent_id
 
1986
                new_dirname = entry[0][0]
 
1987
                if new_dirname == last_target_parent[0]:
 
1988
                    target_parent_id = last_target_parent[1]
 
1989
                else:
 
1990
                    try:
 
1991
                        target_parent_id = new_dirname_to_file_id[new_dirname]
 
1992
                    except KeyError:
 
1993
                        # TODO: We don't always need to do the lookup, because the
 
1994
                        #       parent entry will be the same as the source entry.
 
1995
                        target_parent_entry = state._get_entry(target_index,
 
1996
                                                               path_utf8=new_dirname)
 
1997
                        assert target_parent_entry != (None, None), (
 
1998
                            "Could not find target parent in wt: %s\nparent of: %s"
 
1999
                            % (new_dirname, entry))
 
2000
                        target_parent_id = target_parent_entry[0][2]
 
2001
                    if target_parent_id == entry[0][2]:
 
2002
                        # This is the root, so the parent is None
 
2003
                        target_parent_id = None
 
2004
                    else:
 
2005
                        last_target_parent[0] = new_dirname
 
2006
                        last_target_parent[1] = target_parent_id
 
2007
 
 
2008
                source_exec = source_details[3]
 
2009
                if (include_unchanged
 
2010
                    or content_change
 
2011
                    or source_parent_id != target_parent_id
 
2012
                    or old_basename != entry[0][1]
 
2013
                    or source_exec != target_exec
 
2014
                    ):
 
2015
                    if old_path is None:
 
2016
                        old_path = path = pathjoin(old_dirname, old_basename)
 
2017
                        old_path_u = utf8_decode(old_path)[0]
 
2018
                        path_u = old_path_u
 
2019
                    else:
 
2020
                        old_path_u = utf8_decode(old_path)[0]
 
2021
                        if old_path == path:
 
2022
                            path_u = old_path_u
 
2023
                        else:
 
2024
                            path_u = utf8_decode(path)[0]
 
2025
                    source_kind = _minikind_to_kind[source_minikind]
 
2026
                    return (entry[0][2],
 
2027
                           (old_path_u, path_u),
 
2028
                           content_change,
 
2029
                           (True, True),
 
2030
                           (source_parent_id, target_parent_id),
 
2031
                           (utf8_decode(old_basename)[0], utf8_decode(entry[0][1])[0]),
 
2032
                           (source_kind, target_kind),
 
2033
                           (source_exec, target_exec))
 
2034
                else:
 
2035
                    return uninteresting
 
2036
            elif source_minikind in 'a' and target_minikind in 'fdlt':
 
2037
                # looks like a new file
 
2038
                if path_info is not None:
 
2039
                    path = pathjoin(entry[0][0], entry[0][1])
 
2040
                    # parent id is the entry for the path in the target tree
 
2041
                    # TODO: these are the same for an entire directory: cache em.
 
2042
                    parent_id = state._get_entry(target_index,
 
2043
                                                 path_utf8=entry[0][0])[0][2]
 
2044
                    if parent_id == entry[0][2]:
 
2045
                        parent_id = None
 
2046
                    if use_filesystem_for_exec:
 
2047
                        # We need S_ISREG here, because we aren't sure if this
 
2048
                        # is a file or not.
 
2049
                        target_exec = bool(
 
2050
                            stat.S_ISREG(path_info[3].st_mode)
 
2051
                            and stat.S_IEXEC & path_info[3].st_mode)
 
2052
                    else:
 
2053
                        target_exec = target_details[3]
 
2054
                    return (entry[0][2],
 
2055
                           (None, utf8_decode(path)[0]),
 
2056
                           True,
 
2057
                           (False, True),
 
2058
                           (None, parent_id),
 
2059
                           (None, utf8_decode(entry[0][1])[0]),
 
2060
                           (None, path_info[2]),
 
2061
                           (None, target_exec))
 
2062
                else:
 
2063
                    # but its not on disk: we deliberately treat this as just
 
2064
                    # never-present. (Why ?! - RBC 20070224)
 
2065
                    pass
 
2066
            elif source_minikind in 'fdlt' and target_minikind in 'a':
 
2067
                # unversioned, possibly, or possibly not deleted: we dont care.
 
2068
                # if its still on disk, *and* theres no other entry at this
 
2069
                # path [we dont know this in this routine at the moment -
 
2070
                # perhaps we should change this - then it would be an unknown.
 
2071
                old_path = pathjoin(entry[0][0], entry[0][1])
 
2072
                # parent id is the entry for the path in the target tree
 
2073
                parent_id = state._get_entry(source_index, path_utf8=entry[0][0])[0][2]
 
2074
                if parent_id == entry[0][2]:
 
2075
                    parent_id = None
 
2076
                return (entry[0][2],
 
2077
                       (utf8_decode(old_path)[0], None),
 
2078
                       True,
 
2079
                       (True, False),
 
2080
                       (parent_id, None),
 
2081
                       (utf8_decode(entry[0][1])[0], None),
 
2082
                       (_minikind_to_kind[source_minikind], None),
 
2083
                       (source_details[3], None))
 
2084
            elif source_minikind in 'fdlt' and target_minikind in 'r':
 
2085
                # a rename; could be a true rename, or a rename inherited from
 
2086
                # a renamed parent. TODO: handle this efficiently. Its not
 
2087
                # common case to rename dirs though, so a correct but slow
 
2088
                # implementation will do.
 
2089
                if not osutils.is_inside_any(searched_specific_files, target_details[1]):
 
2090
                    search_specific_files.add(target_details[1])
 
2091
            elif source_minikind in 'ra' and target_minikind in 'ra':
 
2092
                # neither of the selected trees contain this file,
 
2093
                # so skip over it. This is not currently directly tested, but
 
2094
                # is indirectly via test_too_much.TestCommands.test_conflicts.
 
2095
                pass
 
2096
            else:
 
2097
                raise AssertionError("don't know how to compare "
 
2098
                    "source_minikind=%r, target_minikind=%r"
 
2099
                    % (source_minikind, target_minikind))
 
2100
                ## import pdb;pdb.set_trace()
 
2101
            return None
 
2102
 
 
2103
        while search_specific_files:
 
2104
            # TODO: the pending list should be lexically sorted?  the
 
2105
            # interface doesn't require it.
 
2106
            current_root = search_specific_files.pop()
 
2107
            current_root_unicode = current_root.decode('utf8')
 
2108
            searched_specific_files.add(current_root)
 
2109
            # process the entries for this containing directory: the rest will be
 
2110
            # found by their parents recursively.
 
2111
            root_entries = _entries_for_path(current_root)
 
2112
            root_abspath = self.target.abspath(current_root_unicode)
 
2113
            try:
 
2114
                root_stat = os.lstat(root_abspath)
 
2115
            except OSError, e:
 
2116
                if e.errno == errno.ENOENT:
 
2117
                    # the path does not exist: let _process_entry know that.
 
2118
                    root_dir_info = None
 
2119
                else:
 
2120
                    # some other random error: hand it up.
 
2121
                    raise
 
2122
            else:
 
2123
                root_dir_info = ('', current_root,
 
2124
                    osutils.file_kind_from_stat_mode(root_stat.st_mode), root_stat,
 
2125
                    root_abspath)
 
2126
                if root_dir_info[2] == 'directory':
 
2127
                    if self.target._directory_is_tree_reference(
 
2128
                        current_root.decode('utf8')):
 
2129
                        root_dir_info = root_dir_info[:2] + \
 
2130
                            ('tree-reference',) + root_dir_info[3:]
 
2131
 
 
2132
            if not root_entries and not root_dir_info:
 
2133
                # this specified path is not present at all, skip it.
 
2134
                continue
 
2135
            path_handled = False
 
2136
            for entry in root_entries:
 
2137
                result = _process_entry(entry, root_dir_info)
 
2138
                if result is not None:
 
2139
                    path_handled = True
 
2140
                    if result is not uninteresting:
 
2141
                        yield result
 
2142
            if want_unversioned and not path_handled and root_dir_info:
 
2143
                new_executable = bool(
 
2144
                    stat.S_ISREG(root_dir_info[3].st_mode)
 
2145
                    and stat.S_IEXEC & root_dir_info[3].st_mode)
 
2146
                yield (None,
 
2147
                       (None, current_root_unicode),
 
2148
                       True,
 
2149
                       (False, False),
 
2150
                       (None, None),
 
2151
                       (None, splitpath(current_root_unicode)[-1]),
 
2152
                       (None, root_dir_info[2]),
 
2153
                       (None, new_executable)
 
2154
                      )
 
2155
            initial_key = (current_root, '', '')
 
2156
            block_index, _ = state._find_block_index_from_key(initial_key)
 
2157
            if block_index == 0:
 
2158
                # we have processed the total root already, but because the
 
2159
                # initial key matched it we should skip it here.
 
2160
                block_index +=1
 
2161
            if root_dir_info and root_dir_info[2] == 'tree-reference':
 
2162
                current_dir_info = None
 
2163
            else:
 
2164
                dir_iterator = osutils._walkdirs_utf8(root_abspath, prefix=current_root)
 
2165
                try:
 
2166
                    current_dir_info = dir_iterator.next()
 
2167
                except OSError, e:
 
2168
                    # on win32, python2.4 has e.errno == ERROR_DIRECTORY, but
 
2169
                    # python 2.5 has e.errno == EINVAL,
 
2170
                    #            and e.winerror == ERROR_DIRECTORY
 
2171
                    e_winerror = getattr(e, 'winerror', None)
 
2172
                    win_errors = (ERROR_DIRECTORY, ERROR_PATH_NOT_FOUND)
 
2173
                    # there may be directories in the inventory even though
 
2174
                    # this path is not a file on disk: so mark it as end of
 
2175
                    # iterator
 
2176
                    if e.errno in (errno.ENOENT, errno.ENOTDIR, errno.EINVAL):
 
2177
                        current_dir_info = None
 
2178
                    elif (sys.platform == 'win32'
 
2179
                          and (e.errno in win_errors
 
2180
                               or e_winerror in win_errors)):
 
2181
                        current_dir_info = None
 
2182
                    else:
 
2183
                        raise
 
2184
                else:
 
2185
                    if current_dir_info[0][0] == '':
 
2186
                        # remove .bzr from iteration
 
2187
                        bzr_index = bisect_left(current_dir_info[1], ('.bzr',))
 
2188
                        assert current_dir_info[1][bzr_index][0] == '.bzr'
 
2189
                        del current_dir_info[1][bzr_index]
 
2190
            # walk until both the directory listing and the versioned metadata
 
2191
            # are exhausted. 
 
2192
            if (block_index < len(state._dirblocks) and
 
2193
                osutils.is_inside(current_root, state._dirblocks[block_index][0])):
 
2194
                current_block = state._dirblocks[block_index]
 
2195
            else:
 
2196
                current_block = None
 
2197
            while (current_dir_info is not None or
 
2198
                   current_block is not None):
 
2199
                if (current_dir_info and current_block
 
2200
                    and current_dir_info[0][0] != current_block[0]):
 
2201
                    if cmp_by_dirs(current_dir_info[0][0], current_block[0]) < 0:
 
2202
                        # filesystem data refers to paths not covered by the dirblock.
 
2203
                        # this has two possibilities:
 
2204
                        # A) it is versioned but empty, so there is no block for it
 
2205
                        # B) it is not versioned.
 
2206
 
 
2207
                        # if (A) then we need to recurse into it to check for
 
2208
                        # new unknown files or directories.
 
2209
                        # if (B) then we should ignore it, because we don't
 
2210
                        # recurse into unknown directories.
 
2211
                        path_index = 0
 
2212
                        while path_index < len(current_dir_info[1]):
 
2213
                                current_path_info = current_dir_info[1][path_index]
 
2214
                                if want_unversioned:
 
2215
                                    if current_path_info[2] == 'directory':
 
2216
                                        if self.target._directory_is_tree_reference(
 
2217
                                            current_path_info[0].decode('utf8')):
 
2218
                                            current_path_info = current_path_info[:2] + \
 
2219
                                                ('tree-reference',) + current_path_info[3:]
 
2220
                                    new_executable = bool(
 
2221
                                        stat.S_ISREG(current_path_info[3].st_mode)
 
2222
                                        and stat.S_IEXEC & current_path_info[3].st_mode)
 
2223
                                    yield (None,
 
2224
                                        (None, utf8_decode(current_path_info[0])[0]),
 
2225
                                        True,
 
2226
                                        (False, False),
 
2227
                                        (None, None),
 
2228
                                        (None, utf8_decode(current_path_info[1])[0]),
 
2229
                                        (None, current_path_info[2]),
 
2230
                                        (None, new_executable))
 
2231
                                # dont descend into this unversioned path if it is
 
2232
                                # a dir
 
2233
                                if current_path_info[2] in ('directory',
 
2234
                                                            'tree-reference'):
 
2235
                                    del current_dir_info[1][path_index]
 
2236
                                    path_index -= 1
 
2237
                                path_index += 1
 
2238
 
 
2239
                        # This dir info has been handled, go to the next
 
2240
                        try:
 
2241
                            current_dir_info = dir_iterator.next()
 
2242
                        except StopIteration:
 
2243
                            current_dir_info = None
 
2244
                    else:
 
2245
                        # We have a dirblock entry for this location, but there
 
2246
                        # is no filesystem path for this. This is most likely
 
2247
                        # because a directory was removed from the disk.
 
2248
                        # We don't have to report the missing directory,
 
2249
                        # because that should have already been handled, but we
 
2250
                        # need to handle all of the files that are contained
 
2251
                        # within.
 
2252
                        for current_entry in current_block[1]:
 
2253
                            # entry referring to file not present on disk.
 
2254
                            # advance the entry only, after processing.
 
2255
                            result = _process_entry(current_entry, None)
 
2256
                            if result is not None:
 
2257
                                if result is not uninteresting:
 
2258
                                    yield result
 
2259
                        block_index +=1
 
2260
                        if (block_index < len(state._dirblocks) and
 
2261
                            osutils.is_inside(current_root,
 
2262
                                              state._dirblocks[block_index][0])):
 
2263
                            current_block = state._dirblocks[block_index]
 
2264
                        else:
 
2265
                            current_block = None
 
2266
                    continue
 
2267
                entry_index = 0
 
2268
                if current_block and entry_index < len(current_block[1]):
 
2269
                    current_entry = current_block[1][entry_index]
 
2270
                else:
 
2271
                    current_entry = None
 
2272
                advance_entry = True
 
2273
                path_index = 0
 
2274
                if current_dir_info and path_index < len(current_dir_info[1]):
 
2275
                    current_path_info = current_dir_info[1][path_index]
 
2276
                    if current_path_info[2] == 'directory':
 
2277
                        if self.target._directory_is_tree_reference(
 
2278
                            current_path_info[0].decode('utf8')):
 
2279
                            current_path_info = current_path_info[:2] + \
 
2280
                                ('tree-reference',) + current_path_info[3:]
 
2281
                else:
 
2282
                    current_path_info = None
 
2283
                advance_path = True
 
2284
                path_handled = False
 
2285
                while (current_entry is not None or
 
2286
                    current_path_info is not None):
 
2287
                    if current_entry is None:
 
2288
                        # the check for path_handled when the path is adnvaced
 
2289
                        # will yield this path if needed.
 
2290
                        pass
 
2291
                    elif current_path_info is None:
 
2292
                        # no path is fine: the per entry code will handle it.
 
2293
                        result = _process_entry(current_entry, current_path_info)
 
2294
                        if result is not None:
 
2295
                            if result is not uninteresting:
 
2296
                                yield result
 
2297
                    elif (current_entry[0][1] != current_path_info[1]
 
2298
                          or current_entry[1][target_index][0] in 'ar'):
 
2299
                        # The current path on disk doesn't match the dirblock
 
2300
                        # record. Either the dirblock is marked as absent, or
 
2301
                        # the file on disk is not present at all in the
 
2302
                        # dirblock. Either way, report about the dirblock
 
2303
                        # entry, and let other code handle the filesystem one.
 
2304
 
 
2305
                        # Compare the basename for these files to determine
 
2306
                        # which comes first
 
2307
                        if current_path_info[1] < current_entry[0][1]:
 
2308
                            # extra file on disk: pass for now, but only
 
2309
                            # increment the path, not the entry
 
2310
                            advance_entry = False
 
2311
                        else:
 
2312
                            # entry referring to file not present on disk.
 
2313
                            # advance the entry only, after processing.
 
2314
                            result = _process_entry(current_entry, None)
 
2315
                            if result is not None:
 
2316
                                if result is not uninteresting:
 
2317
                                    yield result
 
2318
                            advance_path = False
 
2319
                    else:
 
2320
                        result = _process_entry(current_entry, current_path_info)
 
2321
                        if result is not None:
 
2322
                            path_handled = True
 
2323
                            if result is not uninteresting:
 
2324
                                yield result
 
2325
                    if advance_entry and current_entry is not None:
 
2326
                        entry_index += 1
 
2327
                        if entry_index < len(current_block[1]):
 
2328
                            current_entry = current_block[1][entry_index]
 
2329
                        else:
 
2330
                            current_entry = None
 
2331
                    else:
 
2332
                        advance_entry = True # reset the advance flaga
 
2333
                    if advance_path and current_path_info is not None:
 
2334
                        if not path_handled:
 
2335
                            # unversioned in all regards
 
2336
                            if want_unversioned:
 
2337
                                new_executable = bool(
 
2338
                                    stat.S_ISREG(current_path_info[3].st_mode)
 
2339
                                    and stat.S_IEXEC & current_path_info[3].st_mode)
 
2340
                                yield (None,
 
2341
                                    (None, utf8_decode(current_path_info[0])[0]),
 
2342
                                    True,
 
2343
                                    (False, False),
 
2344
                                    (None, None),
 
2345
                                    (None, utf8_decode(current_path_info[1])[0]),
 
2346
                                    (None, current_path_info[2]),
 
2347
                                    (None, new_executable))
 
2348
                            # dont descend into this unversioned path if it is
 
2349
                            # a dir
 
2350
                            if current_path_info[2] in ('directory'):
 
2351
                                del current_dir_info[1][path_index]
 
2352
                                path_index -= 1
 
2353
                        # dont descend the disk iterator into any tree 
 
2354
                        # paths.
 
2355
                        if current_path_info[2] == 'tree-reference':
 
2356
                            del current_dir_info[1][path_index]
 
2357
                            path_index -= 1
 
2358
                        path_index += 1
 
2359
                        if path_index < len(current_dir_info[1]):
 
2360
                            current_path_info = current_dir_info[1][path_index]
 
2361
                            if current_path_info[2] == 'directory':
 
2362
                                if self.target._directory_is_tree_reference(
 
2363
                                    current_path_info[0].decode('utf8')):
 
2364
                                    current_path_info = current_path_info[:2] + \
 
2365
                                        ('tree-reference',) + current_path_info[3:]
 
2366
                        else:
 
2367
                            current_path_info = None
 
2368
                        path_handled = False
 
2369
                    else:
 
2370
                        advance_path = True # reset the advance flagg.
 
2371
                if current_block is not None:
 
2372
                    block_index += 1
 
2373
                    if (block_index < len(state._dirblocks) and
 
2374
                        osutils.is_inside(current_root, state._dirblocks[block_index][0])):
 
2375
                        current_block = state._dirblocks[block_index]
 
2376
                    else:
 
2377
                        current_block = None
 
2378
                if current_dir_info is not None:
 
2379
                    try:
 
2380
                        current_dir_info = dir_iterator.next()
 
2381
                    except StopIteration:
 
2382
                        current_dir_info = None
 
2383
 
2093
2384
 
2094
2385
    @staticmethod
2095
2386
    def is_compatible(source, target):
2096
2387
        # the target must be a dirstate working tree
2097
 
        if not isinstance(target, DirStateWorkingTree):
 
2388
        if not isinstance(target, WorkingTree4):
2098
2389
            return False
2099
 
        # the source must be a revtree or dirstate rev tree.
 
2390
        # the source must be a revtreee or dirstate rev tree.
2100
2391
        if not isinstance(source,
2101
2392
            (revisiontree.RevisionTree, DirStateRevisionTree)):
2102
2393
            return False
2103
2394
        # the source revid must be in the target dirstate
2104
 
        if not (source._revision_id == _mod_revision.NULL_REVISION or
 
2395
        if not (source._revision_id == NULL_REVISION or
2105
2396
            source._revision_id in target.get_parent_ids()):
2106
 
            # TODO: what about ghosts? it may well need to
 
2397
            # TODO: what about ghosts? it may well need to 
2107
2398
            # check for them explicitly.
2108
2399
            return False
2109
2400
        return True
2119
2410
 
2120
2411
    def convert(self, tree):
2121
2412
        # lock the control files not the tree, so that we dont get tree
2122
 
        # on-unlock behaviours, and so that noone else diddles with the
 
2413
        # on-unlock behaviours, and so that noone else diddles with the 
2123
2414
        # tree during upgrade.
2124
2415
        tree._control_files.lock_write()
2125
2416
        try:
2151
2442
 
2152
2443
    def update_format(self, tree):
2153
2444
        """Change the format marker."""
2154
 
        tree._transport.put_bytes('format',
2155
 
            self.target_format.get_format_string(),
2156
 
            mode=tree.bzrdir._get_file_mode())
2157
 
 
2158
 
 
2159
 
class Converter4to5(object):
2160
 
    """Perform an in-place upgrade of format 4 to format 5 trees."""
2161
 
 
2162
 
    def __init__(self):
2163
 
        self.target_format = WorkingTreeFormat5()
2164
 
 
2165
 
    def convert(self, tree):
2166
 
        # lock the control files not the tree, so that we don't get tree
2167
 
        # on-unlock behaviours, and so that no-one else diddles with the
2168
 
        # tree during upgrade.
2169
 
        tree._control_files.lock_write()
2170
 
        try:
2171
 
            self.update_format(tree)
2172
 
        finally:
2173
 
            tree._control_files.unlock()
2174
 
 
2175
 
    def update_format(self, tree):
2176
 
        """Change the format marker."""
2177
 
        tree._transport.put_bytes('format',
2178
 
            self.target_format.get_format_string(),
2179
 
            mode=tree.bzrdir._get_file_mode())
2180
 
 
2181
 
 
2182
 
class Converter4or5to6(object):
2183
 
    """Perform an in-place upgrade of format 4 or 5 to format 6 trees."""
2184
 
 
2185
 
    def __init__(self):
2186
 
        self.target_format = WorkingTreeFormat6()
2187
 
 
2188
 
    def convert(self, tree):
2189
 
        # lock the control files not the tree, so that we don't get tree
2190
 
        # on-unlock behaviours, and so that no-one else diddles with the
2191
 
        # tree during upgrade.
2192
 
        tree._control_files.lock_write()
2193
 
        try:
2194
 
            self.init_custom_control_files(tree)
2195
 
            self.update_format(tree)
2196
 
        finally:
2197
 
            tree._control_files.unlock()
2198
 
 
2199
 
    def init_custom_control_files(self, tree):
2200
 
        """Initialize custom control files."""
2201
 
        tree._transport.put_bytes('views', '',
2202
 
            mode=tree.bzrdir._get_file_mode())
2203
 
 
2204
 
    def update_format(self, tree):
2205
 
        """Change the format marker."""
2206
 
        tree._transport.put_bytes('format',
2207
 
            self.target_format.get_format_string(),
2208
 
            mode=tree.bzrdir._get_file_mode())
 
2445
        tree._control_files.put_utf8('format',
 
2446
            self.target_format.get_format_string())