/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

  • Committer: Robert Collins
  • Date: 2007-07-03 02:33:32 UTC
  • mto: This revision was merged to the branch mainline in revision 2581.
  • Revision ID: robertc@robertcollins.net-20070703023332-jz0qdt2dwhzjuhlc
* ``bzrlib.add.smart_add`` and ``bzrlib.add.smart_add_tree`` are now
  deprecated in favour of ``MutableTree.smart_add``. (Robert Collins,
  Martin Pool)

Show diffs side-by-side

added added

removed removed

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