/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 breezy/bzr/workingtree_4.py

  • Committer: Jelmer Vernooij
  • Date: 2020-05-24 00:42:36 UTC
  • mto: This revision was merged to the branch mainline in revision 7505.
  • Revision ID: jelmer@jelmer.uk-20200524004236-jdj6obo4k5lznqw2
Cleanup Windows functions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/bzr/workingtree_4.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2007-2012 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
22
22
WorkingTree.open(dir).
23
23
"""
24
24
 
25
 
from cStringIO import StringIO
 
25
from io import BytesIO
26
26
import os
27
 
import sys
28
27
 
29
 
from bzrlib.lazy_import import lazy_import
 
28
from ..lazy_import import lazy_import
30
29
lazy_import(globals(), """
 
30
import contextlib
31
31
import errno
32
32
import stat
33
33
 
34
 
import bzrlib
35
 
from bzrlib import (
36
 
    bzrdir,
 
34
from breezy import (
 
35
    branch as _mod_branch,
37
36
    cache_utf8,
 
37
    controldir,
38
38
    debug,
39
 
    dirstate,
40
 
    errors,
41
 
    generate_ids,
 
39
    filters as _mod_filters,
42
40
    osutils,
43
41
    revision as _mod_revision,
44
42
    revisiontree,
46
44
    transform,
47
45
    views,
48
46
    )
49
 
import bzrlib.branch
50
 
import bzrlib.ui
 
47
from breezy.bzr import (
 
48
    dirstate,
 
49
    generate_ids,
 
50
    )
51
51
""")
52
52
 
53
 
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
56
 
from bzrlib.lock import LogicalLockResult
57
 
from bzrlib.mutabletree import needs_tree_write_lock
58
 
from bzrlib.osutils import (
 
53
from .. import (
 
54
    errors,
 
55
    )
 
56
from .inventory import Inventory, ROOT_ID, entry_factory
 
57
from ..lock import LogicalLockResult
 
58
from ..lockable_files import LockableFiles
 
59
from ..lockdir import LockDir
 
60
from .inventorytree import (
 
61
    InventoryTree,
 
62
    InventoryRevisionTree,
 
63
    )
 
64
from ..mutabletree import (
 
65
    BadReferenceTarget,
 
66
    MutableTree,
 
67
    )
 
68
from ..osutils import (
59
69
    file_kind,
60
70
    isdir,
61
71
    pathjoin,
62
72
    realpath,
63
73
    safe_unicode,
64
74
    )
65
 
from bzrlib.trace import mutter
66
 
from bzrlib.transport.local import LocalTransport
67
 
from bzrlib.tree import InterTree
68
 
from bzrlib.tree import Tree
69
 
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
70
 
 
71
 
 
72
 
class DirStateWorkingTree(WorkingTree3):
 
75
from ..transport import get_transport_from_path
 
76
from ..transport.local import LocalTransport
 
77
from ..tree import (
 
78
    FileTimestampUnavailable,
 
79
    InterTree,
 
80
    MissingNestedTree,
 
81
    )
 
82
from ..workingtree import (
 
83
    WorkingTree,
 
84
    )
 
85
from .workingtree import (
 
86
    InventoryWorkingTree,
 
87
    WorkingTreeFormatMetaDir,
 
88
    )
 
89
 
 
90
 
 
91
class DirStateWorkingTree(InventoryWorkingTree):
 
92
 
73
93
    def __init__(self, basedir,
74
94
                 branch,
75
95
                 _control_files=None,
76
96
                 _format=None,
77
 
                 _bzrdir=None):
 
97
                 _controldir=None):
78
98
        """Construct a WorkingTree for basedir.
79
99
 
80
100
        If the branch is not supplied, it is opened automatically.
83
103
        would be meaningless).
84
104
        """
85
105
        self._format = _format
86
 
        self.bzrdir = _bzrdir
 
106
        self.controldir = _controldir
87
107
        basedir = safe_unicode(basedir)
88
 
        mutter("opening working tree %r", basedir)
 
108
        trace.mutter("opening working tree %r", basedir)
89
109
        self._branch = branch
90
110
        self.basedir = realpath(basedir)
91
111
        # if branch is at our basedir and is a format 6 or less
93
113
        self._control_files = _control_files
94
114
        self._transport = self._control_files._transport
95
115
        self._dirty = None
96
 
        #-------------
 
116
        # -------------
97
117
        # during a read or write lock these objects are set, and are
98
118
        # None the rest of the time.
99
119
        self._dirstate = None
100
120
        self._inventory = None
101
 
        #-------------
 
121
        # -------------
102
122
        self._setup_directory_is_tree_reference()
103
123
        self._detect_case_handling()
104
124
        self._rules_searcher = None
105
125
        self.views = self._make_views()
106
 
        #--- allow tests to select the dirstate iter_changes implementation
 
126
        # --- allow tests to select the dirstate iter_changes implementation
107
127
        self._iter_changes = dirstate._process_entry
 
128
        self._repo_supports_tree_reference = getattr(
 
129
            self._branch.repository._format, "supports_tree_reference",
 
130
            False)
108
131
 
109
 
    @needs_tree_write_lock
110
132
    def _add(self, files, ids, kinds):
111
133
        """See MutableTree._add."""
112
 
        state = self.current_dirstate()
113
 
        for f, file_id, kind in zip(files, ids, kinds):
114
 
            f = f.strip('/')
115
 
            if self.path2id(f):
116
 
                # special case tree root handling.
117
 
                if f == '' and self.path2id(f) == ROOT_ID:
118
 
                    state.set_path_id('', generate_ids.gen_file_id(f))
119
 
                continue
120
 
            if file_id is None:
121
 
                file_id = generate_ids.gen_file_id(f)
122
 
            # deliberately add the file with no cached stat or sha1
123
 
            # - on the first access it will be gathered, and we can
124
 
            # always change this once tests are all passing.
125
 
            state.add(f, file_id, kind, None, '')
126
 
        self._make_dirty(reset_inventory=True)
 
134
        with self.lock_tree_write():
 
135
            state = self.current_dirstate()
 
136
            for f, file_id, kind in zip(files, ids, kinds):
 
137
                f = f.strip(u'/')
 
138
                if self.path2id(f):
 
139
                    # special case tree root handling.
 
140
                    if f == b'' and self.path2id(f) == ROOT_ID:
 
141
                        state.set_path_id(b'', generate_ids.gen_file_id(f))
 
142
                    continue
 
143
                if file_id is None:
 
144
                    file_id = generate_ids.gen_file_id(f)
 
145
                # deliberately add the file with no cached stat or sha1
 
146
                # - on the first access it will be gathered, and we can
 
147
                # always change this once tests are all passing.
 
148
                state.add(f, file_id, kind, None, b'')
 
149
            self._make_dirty(reset_inventory=True)
 
150
 
 
151
    def _get_check_refs(self):
 
152
        """Return the references needed to perform a check of this tree."""
 
153
        return [('trees', self.last_revision())]
127
154
 
128
155
    def _make_dirty(self, reset_inventory):
129
156
        """Make the tree state dirty.
135
162
        if reset_inventory and self._inventory is not None:
136
163
            self._inventory = None
137
164
 
138
 
    @needs_tree_write_lock
139
165
    def add_reference(self, sub_tree):
140
166
        # use standard implementation, which calls back to self._add
141
167
        #
142
168
        # So we don't store the reference_revision in the working dirstate,
143
169
        # it's just recorded at the moment of commit.
144
 
        self._add_reference(sub_tree)
 
170
        with self.lock_tree_write():
 
171
            try:
 
172
                sub_tree_path = self.relpath(sub_tree.basedir)
 
173
            except errors.PathNotChild:
 
174
                raise BadReferenceTarget(self, sub_tree,
 
175
                                         'Target not inside tree.')
 
176
            sub_tree_id = sub_tree.path2id('')
 
177
            if sub_tree_id == self.path2id(''):
 
178
                raise BadReferenceTarget(self, sub_tree,
 
179
                                         'Trees have the same root id.')
 
180
            try:
 
181
                self.id2path(sub_tree_id)
 
182
            except errors.NoSuchId:
 
183
                pass
 
184
            else:
 
185
                raise BadReferenceTarget(
 
186
                    self, sub_tree, 'Root id already present in tree')
 
187
            self._add([sub_tree_path], [sub_tree_id], ['tree-reference'])
145
188
 
146
189
    def break_lock(self):
147
190
        """Break a lock if one is present from another instance.
182
225
 
183
226
    def _comparison_data(self, entry, path):
184
227
        kind, executable, stat_value = \
185
 
            WorkingTree3._comparison_data(self, entry, path)
 
228
            WorkingTree._comparison_data(self, entry, path)
186
229
        # it looks like a plain directory, but it's really a reference -- see
187
230
        # also kind()
188
231
        if (self._repo_supports_tree_reference and kind == 'directory'
189
 
            and entry is not None and entry.kind == 'tree-reference'):
 
232
                and entry is not None and entry.kind == 'tree-reference'):
190
233
            kind = 'tree-reference'
191
234
        return kind, executable, stat_value
192
235
 
193
 
    @needs_write_lock
194
236
    def commit(self, message=None, revprops=None, *args, **kwargs):
195
 
        # mark the tree as dirty post commit - commit
196
 
        # can change the current versioned list by doing deletes.
197
 
        result = WorkingTree3.commit(self, message, revprops, *args, **kwargs)
198
 
        self._make_dirty(reset_inventory=True)
199
 
        return result
 
237
        with self.lock_write():
 
238
            # mark the tree as dirty post commit - commit
 
239
            # can change the current versioned list by doing deletes.
 
240
            result = WorkingTree.commit(self, message, revprops, *args,
 
241
                                        **kwargs)
 
242
            self._make_dirty(reset_inventory=True)
 
243
            return result
200
244
 
201
245
    def current_dirstate(self):
202
246
        """Return the current dirstate object.
216
260
        """
217
261
        if self._dirstate is not None:
218
262
            return self._dirstate
219
 
        local_path = self.bzrdir.get_workingtree_transport(None
220
 
            ).local_abspath('dirstate')
221
 
        self._dirstate = dirstate.DirState.on_file(local_path,
222
 
            self._sha1_provider())
 
263
        local_path = self.controldir.get_workingtree_transport(
 
264
            None).local_abspath('dirstate')
 
265
        self._dirstate = dirstate.DirState.on_file(
 
266
            local_path, self._sha1_provider(), self._worth_saving_limit(),
 
267
            self._supports_executable())
223
268
        return self._dirstate
224
269
 
225
270
    def _sha1_provider(self):
234
279
        else:
235
280
            return None
236
281
 
 
282
    def _worth_saving_limit(self):
 
283
        """How many hash changes are ok before we must save the dirstate.
 
284
 
 
285
        :return: an integer. -1 means never save.
 
286
        """
 
287
        conf = self.get_config_stack()
 
288
        return conf.get('bzr.workingtree.worth_saving_limit')
 
289
 
237
290
    def filter_unversioned_files(self, paths):
238
291
        """Filter out paths that are versioned.
239
292
 
262
315
        self._inventory = None
263
316
        self._dirty = False
264
317
 
265
 
    @needs_tree_write_lock
266
318
    def _gather_kinds(self, files, kinds):
267
319
        """See MutableTree._gather_kinds."""
268
 
        for pos, f in enumerate(files):
269
 
            if kinds[pos] is None:
270
 
                kinds[pos] = self._kind(f)
 
320
        with self.lock_tree_write():
 
321
            for pos, f in enumerate(files):
 
322
                if kinds[pos] is None:
 
323
                    kinds[pos] = self.kind(f)
271
324
 
272
325
    def _generate_inventory(self):
273
326
        """Create and set self.inventory from the dirstate object.
281
334
        state._read_dirblocks_if_needed()
282
335
        root_key, current_entry = self._get_entry(path='')
283
336
        current_id = root_key[2]
284
 
        if not (current_entry[0][0] == 'd'): # directory
 
337
        if not (current_entry[0][0] == b'd'):  # directory
285
338
            raise AssertionError(current_entry)
286
339
        inv = Inventory(root_id=current_id)
287
340
        # Turn some things into local variables
291
344
        inv_byid = inv._byid
292
345
        # we could do this straight out of the dirstate; it might be fast
293
346
        # and should be profiled - RBC 20070216
294
 
        parent_ies = {'' : inv.root}
295
 
        for block in state._dirblocks[1:]: # skip the root
 
347
        parent_ies = {b'': inv.root}
 
348
        for block in state._dirblocks[1:]:  # skip the root
296
349
            dirname = block[0]
297
350
            try:
298
351
                parent_ie = parent_ies[dirname]
301
354
                continue
302
355
            for key, entry in block[1]:
303
356
                minikind, link_or_sha1, size, executable, stat = entry[0]
304
 
                if minikind in ('a', 'r'): # absent, relocated
 
357
                if minikind in (b'a', b'r'):  # absent, relocated
305
358
                    # a parent tree only entry
306
359
                    continue
307
360
                name = key[1]
315
368
                    # we know the executable bit.
316
369
                    inv_entry.executable = executable
317
370
                    # not strictly needed: working tree
318
 
                    #inv_entry.text_size = size
319
 
                    #inv_entry.text_sha1 = sha1
 
371
                    # inv_entry.text_size = size
 
372
                    # inv_entry.text_sha1 = sha1
320
373
                elif kind == 'directory':
321
374
                    # add this entry to the parent map.
322
 
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
 
375
                    parent_ies[(dirname + b'/' + name).strip(b'/')] = inv_entry
323
376
                elif kind == 'tree-reference':
324
 
                    if not self._repo_supports_tree_reference:
325
 
                        raise errors.UnsupportedOperation(
326
 
                            self._generate_inventory,
327
 
                            self.branch.repository)
328
377
                    inv_entry.reference_revision = link_or_sha1 or None
329
378
                elif kind != 'symlink':
330
379
                    raise AssertionError("unknown kind %r" % kind)
331
380
                # These checks cost us around 40ms on a 55k entry tree
332
381
                if file_id in inv_byid:
333
 
                    raise AssertionError('file_id %s already in'
 
382
                    raise AssertionError(
 
383
                        'file_id %s already in'
334
384
                        ' inventory as %s' % (file_id, inv_byid[file_id]))
335
385
                if name_unicode in parent_ie.children:
336
386
                    raise AssertionError('name %r already in parent'
337
 
                        % (name_unicode,))
 
387
                                         % (name_unicode,))
338
388
                inv_byid[file_id] = inv_entry
339
389
                parent_ie.children[name_unicode] = inv_entry
340
390
        self._inventory = inv
357
407
            path = path.encode('utf8')
358
408
        return state._get_entry(0, fileid_utf8=file_id, path_utf8=path)
359
409
 
360
 
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
410
    def get_file_sha1(self, path, stat_value=None):
361
411
        # check file id is valid unconditionally.
362
 
        entry = self._get_entry(file_id=file_id, path=path)
 
412
        entry = self._get_entry(path=path)
363
413
        if entry[0] is None:
364
 
            raise errors.NoSuchId(self, file_id)
 
414
            raise errors.NoSuchFile(self, path)
365
415
        if path is None:
366
416
            path = pathjoin(entry[0][0], entry[0][1]).decode('utf8')
367
417
 
369
419
        state = self.current_dirstate()
370
420
        if stat_value is None:
371
421
            try:
372
 
                stat_value = os.lstat(file_abspath)
373
 
            except OSError, e:
 
422
                stat_value = osutils.lstat(file_abspath)
 
423
            except OSError as e:
374
424
                if e.errno == errno.ENOENT:
375
425
                    return None
376
426
                else:
377
427
                    raise
378
428
        link_or_sha1 = dirstate.update_entry(state, entry, file_abspath,
379
 
            stat_value=stat_value)
380
 
        if entry[1][0][0] == 'f':
 
429
                                             stat_value=stat_value)
 
430
        if entry[1][0][0] == b'f':
381
431
            if link_or_sha1 is None:
382
 
                file_obj, statvalue = self.get_file_with_stat(file_id, path)
 
432
                file_obj, statvalue = self.get_file_with_stat(path)
383
433
                try:
384
434
                    sha1 = osutils.sha_file(file_obj)
385
435
                finally:
386
436
                    file_obj.close()
387
 
                self._observed_sha1(file_id, path, (sha1, statvalue))
 
437
                self._observed_sha1(path, (sha1, statvalue))
388
438
                return sha1
389
439
            else:
390
440
                return link_or_sha1
391
441
        return None
392
442
 
393
 
    def _get_inventory(self):
 
443
    def _get_root_inventory(self):
394
444
        """Get the inventory for the tree. This is only valid within a lock."""
395
445
        if 'evil' in debug.debug_flags:
396
 
            trace.mutter_callsite(2,
397
 
                "accessing .inventory forces a size of tree translation.")
 
446
            trace.mutter_callsite(
 
447
                2, "accessing .inventory forces a size of tree translation.")
398
448
        if self._inventory is not None:
399
449
            return self._inventory
400
450
        self._must_be_locked()
401
451
        self._generate_inventory()
402
452
        return self._inventory
403
453
 
404
 
    inventory = property(_get_inventory,
405
 
                         doc="Inventory of this Tree")
 
454
    root_inventory = property(_get_root_inventory,
 
455
                              "Root inventory of this tree")
406
456
 
407
 
    @needs_read_lock
408
457
    def get_parent_ids(self):
409
458
        """See Tree.get_parent_ids.
410
459
 
411
460
        This implementation requests the ids list from the dirstate file.
412
461
        """
413
 
        return self.current_dirstate().get_parent_ids()
 
462
        with self.lock_read():
 
463
            return self.current_dirstate().get_parent_ids()
414
464
 
415
 
    def get_reference_revision(self, file_id, path=None):
 
465
    def get_reference_revision(self, path):
416
466
        # referenced tree's revision is whatever's currently there
417
 
        return self.get_nested_tree(file_id, path).last_revision()
 
467
        return self.get_nested_tree(path).last_revision()
418
468
 
419
 
    def get_nested_tree(self, file_id, path=None):
420
 
        if path is None:
421
 
            path = self.id2path(file_id)
422
 
        # else: check file_id is at path?
 
469
    def get_nested_tree(self, path):
423
470
        return WorkingTree.open(self.abspath(path))
424
471
 
425
 
    @needs_read_lock
426
 
    def get_root_id(self):
427
 
        """Return the id of this trees root"""
428
 
        return self._get_entry(path='')[0][2]
429
 
 
430
 
    def has_id(self, file_id):
431
 
        state = self.current_dirstate()
432
 
        row, parents = self._get_entry(file_id=file_id)
433
 
        if row is None:
434
 
            return False
435
 
        return osutils.lexists(pathjoin(
436
 
                    self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
437
 
 
438
 
    def has_or_had_id(self, file_id):
439
 
        state = self.current_dirstate()
440
 
        row, parents = self._get_entry(file_id=file_id)
441
 
        return row is not None
442
 
 
443
 
    @needs_read_lock
444
 
    def id2path(self, file_id):
 
472
    def id2path(self, file_id, recurse='down'):
445
473
        "Convert a file-id to a path."
446
 
        state = self.current_dirstate()
447
 
        entry = self._get_entry(file_id=file_id)
448
 
        if entry == (None, None):
449
 
            raise errors.NoSuchId(tree=self, file_id=file_id)
450
 
        path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
451
 
        return path_utf8.decode('utf8')
 
474
        with self.lock_read():
 
475
            state = self.current_dirstate()
 
476
            entry = self._get_entry(file_id=file_id)
 
477
            if entry == (None, None):
 
478
                if recurse == 'down':
 
479
                    if 'evil' in debug.debug_flags:
 
480
                        trace.mutter_callsite(
 
481
                            2, "Tree.id2path scans all nested trees.")
 
482
                    for nested_path in self.iter_references():
 
483
                        nested_tree = self.get_nested_tree(nested_path)
 
484
                        try:
 
485
                            return osutils.pathjoin(
 
486
                                nested_path, nested_tree.id2path(file_id))
 
487
                        except errors.NoSuchId:
 
488
                            pass
 
489
                raise errors.NoSuchId(tree=self, file_id=file_id)
 
490
            path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
 
491
            return path_utf8.decode('utf8')
452
492
 
453
493
    def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
454
494
        entry = self._get_entry(path=path)
455
495
        if entry == (None, None):
456
 
            return False # Missing entries are not executable
457
 
        return entry[1][0][3] # Executable?
458
 
 
459
 
    if not osutils.supports_executable():
460
 
        def is_executable(self, file_id, path=None):
461
 
            """Test if a file is executable or not.
462
 
 
463
 
            Note: The caller is expected to take a read-lock before calling this.
464
 
            """
465
 
            entry = self._get_entry(file_id=file_id, path=path)
 
496
            return False  # Missing entries are not executable
 
497
        return entry[1][0][3]  # Executable?
 
498
 
 
499
    def is_executable(self, path):
 
500
        """Test if a file is executable or not.
 
501
 
 
502
        Note: The caller is expected to take a read-lock before calling this.
 
503
        """
 
504
        if not self._supports_executable():
 
505
            entry = self._get_entry(path=path)
466
506
            if entry == (None, None):
467
507
                return False
468
508
            return entry[1][0][3]
469
 
 
470
 
        _is_executable_from_path_and_stat = \
471
 
            _is_executable_from_path_and_stat_from_basis
472
 
    else:
473
 
        def is_executable(self, file_id, path=None):
474
 
            """Test if a file is executable or not.
475
 
 
476
 
            Note: The caller is expected to take a read-lock before calling this.
477
 
            """
 
509
        else:
478
510
            self._must_be_locked()
479
 
            if not path:
480
 
                path = self.id2path(file_id)
481
 
            mode = os.lstat(self.abspath(path)).st_mode
 
511
            mode = osutils.lstat(self.abspath(path)).st_mode
482
512
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
483
513
 
484
514
    def all_file_ids(self):
486
516
        self._must_be_locked()
487
517
        result = set()
488
518
        for key, tree_details in self.current_dirstate()._iter_entries():
489
 
            if tree_details[0][0] in ('a', 'r'): # relocated
 
519
            if tree_details[0][0] in (b'a', b'r'):  # relocated
490
520
                continue
491
521
            result.add(key[2])
492
522
        return result
493
523
 
494
 
    @needs_read_lock
 
524
    def all_versioned_paths(self):
 
525
        self._must_be_locked()
 
526
        return {path for path, entry in
 
527
                self.root_inventory.iter_entries(recursive=True)}
 
528
 
495
529
    def __iter__(self):
496
530
        """Iterate through file_ids for this tree.
497
531
 
498
532
        file_ids are in a WorkingTree if they are in the working inventory
499
533
        and the working file exists.
500
534
        """
501
 
        result = []
502
 
        for key, tree_details in self.current_dirstate()._iter_entries():
503
 
            if tree_details[0][0] in ('a', 'r'): # absent, relocated
504
 
                # not relevant to the working tree
505
 
                continue
506
 
            path = pathjoin(self.basedir, key[0].decode('utf8'), key[1].decode('utf8'))
507
 
            if osutils.lexists(path):
508
 
                result.append(key[2])
509
 
        return iter(result)
 
535
        with self.lock_read():
 
536
            result = []
 
537
            for key, tree_details in self.current_dirstate()._iter_entries():
 
538
                if tree_details[0][0] in (b'a', b'r'):  # absent, relocated
 
539
                    # not relevant to the working tree
 
540
                    continue
 
541
                path = pathjoin(self.basedir, key[0].decode(
 
542
                    'utf8'), key[1].decode('utf8'))
 
543
                if osutils.lexists(path):
 
544
                    result.append(key[2])
 
545
            return iter(result)
510
546
 
511
547
    def iter_references(self):
512
548
        if not self._repo_supports_tree_reference:
513
549
            # When the repo doesn't support references, we will have nothing to
514
550
            # return
515
551
            return
516
 
        for key, tree_details in self.current_dirstate()._iter_entries():
517
 
            if tree_details[0][0] in ('a', 'r'): # absent, relocated
518
 
                # not relevant to the working tree
519
 
                continue
520
 
            if not key[1]:
521
 
                # the root is not a reference.
522
 
                continue
523
 
            relpath = pathjoin(key[0].decode('utf8'), key[1].decode('utf8'))
524
 
            try:
525
 
                if self._kind(relpath) == 'tree-reference':
526
 
                    yield relpath, key[2]
527
 
            except errors.NoSuchFile:
528
 
                # path is missing on disk.
529
 
                continue
 
552
        with self.lock_read():
 
553
            for key, tree_details in self.current_dirstate()._iter_entries():
 
554
                if tree_details[0][0] in (b'a', b'r'):  # absent, relocated
 
555
                    # not relevant to the working tree
 
556
                    continue
 
557
                if not key[1]:
 
558
                    # the root is not a reference.
 
559
                    continue
 
560
                relpath = pathjoin(key[0].decode('utf8'), key[1].decode('utf8'))
 
561
                try:
 
562
                    if self.kind(relpath) == 'tree-reference':
 
563
                        yield relpath
 
564
                except errors.NoSuchFile:
 
565
                    # path is missing on disk.
 
566
                    continue
530
567
 
531
 
    def _observed_sha1(self, file_id, path, (sha1, statvalue)):
 
568
    def _observed_sha1(self, path, sha_and_stat):
532
569
        """See MutableTree._observed_sha1."""
533
570
        state = self.current_dirstate()
534
 
        entry = self._get_entry(file_id=file_id, path=path)
535
 
        state._observed_sha1(entry, sha1, statvalue)
536
 
 
537
 
    def kind(self, file_id):
538
 
        """Return the kind of a file.
539
 
 
540
 
        This is always the actual kind that's on disk, regardless of what it
541
 
        was added as.
542
 
 
543
 
        Note: The caller is expected to take a read-lock before calling this.
544
 
        """
545
 
        relpath = self.id2path(file_id)
546
 
        if relpath is None:
547
 
            raise AssertionError(
548
 
                "path for id {%s} is None!" % file_id)
549
 
        return self._kind(relpath)
550
 
 
551
 
    def _kind(self, relpath):
 
571
        entry = self._get_entry(path=path)
 
572
        state._observed_sha1(entry, *sha_and_stat)
 
573
 
 
574
    def kind(self, relpath):
552
575
        abspath = self.abspath(relpath)
553
576
        kind = file_kind(abspath)
554
577
        if (self._repo_supports_tree_reference and kind == 'directory'):
555
 
            entry = self._get_entry(path=relpath)
556
 
            if entry[1] is not None:
557
 
                if entry[1][0][0] == 't':
558
 
                    kind = 'tree-reference'
 
578
            with self.lock_read():
 
579
                entry = self._get_entry(path=relpath)
 
580
                if entry[1] is not None:
 
581
                    if entry[1][0][0] == b't':
 
582
                        kind = 'tree-reference'
559
583
        return kind
560
584
 
561
 
    @needs_read_lock
562
585
    def _last_revision(self):
563
586
        """See Mutable.last_revision."""
564
 
        parent_ids = self.current_dirstate().get_parent_ids()
565
 
        if parent_ids:
566
 
            return parent_ids[0]
567
 
        else:
568
 
            return _mod_revision.NULL_REVISION
 
587
        with self.lock_read():
 
588
            parent_ids = self.current_dirstate().get_parent_ids()
 
589
            if parent_ids:
 
590
                return parent_ids[0]
 
591
            else:
 
592
                return _mod_revision.NULL_REVISION
569
593
 
570
594
    def lock_read(self):
571
595
        """See Branch.lock_read, and WorkingTree.unlock.
572
596
 
573
 
        :return: A bzrlib.lock.LogicalLockResult.
 
597
        :return: A breezy.lock.LogicalLockResult.
574
598
        """
575
599
        self.branch.lock_read()
576
600
        try:
584
608
                self._repo_supports_tree_reference = getattr(
585
609
                    self.branch.repository._format, "supports_tree_reference",
586
610
                    False)
587
 
            except:
 
611
            except BaseException:
588
612
                self._control_files.unlock()
589
613
                raise
590
 
        except:
 
614
        except BaseException:
591
615
            self.branch.unlock()
592
616
            raise
593
617
        return LogicalLockResult(self.unlock)
605
629
                self._repo_supports_tree_reference = getattr(
606
630
                    self.branch.repository._format, "supports_tree_reference",
607
631
                    False)
608
 
            except:
 
632
            except BaseException:
609
633
                self._control_files.unlock()
610
634
                raise
611
 
        except:
 
635
        except BaseException:
612
636
            self.branch.unlock()
613
637
            raise
614
638
        return LogicalLockResult(self.unlock)
616
640
    def lock_tree_write(self):
617
641
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
618
642
 
619
 
        :return: A bzrlib.lock.LogicalLockResult.
 
643
        :return: A breezy.lock.LogicalLockResult.
620
644
        """
621
645
        self.branch.lock_read()
622
646
        return self._lock_self_write()
624
648
    def lock_write(self):
625
649
        """See MutableTree.lock_write, and WorkingTree.unlock.
626
650
 
627
 
        :return: A bzrlib.lock.LogicalLockResult.
 
651
        :return: A breezy.lock.LogicalLockResult.
628
652
        """
629
653
        self.branch.lock_write()
630
654
        return self._lock_self_write()
631
655
 
632
 
    @needs_tree_write_lock
633
656
    def move(self, from_paths, to_dir, after=False):
634
657
        """See WorkingTree.move()."""
635
658
        result = []
636
659
        if not from_paths:
637
660
            return result
638
 
        state = self.current_dirstate()
639
 
        if isinstance(from_paths, basestring):
640
 
            raise ValueError()
641
 
        to_dir_utf8 = to_dir.encode('utf8')
642
 
        to_entry_dirname, to_basename = os.path.split(to_dir_utf8)
643
 
        id_index = state._get_id_index()
644
 
        # check destination directory
645
 
        # get the details for it
646
 
        to_entry_block_index, to_entry_entry_index, dir_present, entry_present = \
647
 
            state._get_block_entry_index(to_entry_dirname, to_basename, 0)
648
 
        if not entry_present:
649
 
            raise errors.BzrMoveFailedError('', to_dir,
650
 
                errors.NotVersionedError(to_dir))
651
 
        to_entry = state._dirblocks[to_entry_block_index][1][to_entry_entry_index]
652
 
        # get a handle on the block itself.
653
 
        to_block_index = state._ensure_block(
654
 
            to_entry_block_index, to_entry_entry_index, to_dir_utf8)
655
 
        to_block = state._dirblocks[to_block_index]
656
 
        to_abs = self.abspath(to_dir)
657
 
        if not isdir(to_abs):
658
 
            raise errors.BzrMoveFailedError('',to_dir,
659
 
                errors.NotADirectory(to_abs))
660
 
 
661
 
        if to_entry[1][0][0] != 'd':
662
 
            raise errors.BzrMoveFailedError('',to_dir,
663
 
                errors.NotADirectory(to_abs))
664
 
 
665
 
        if self._inventory is not None:
666
 
            update_inventory = True
667
 
            inv = self.inventory
668
 
            to_dir_id = to_entry[0][2]
669
 
            to_dir_ie = inv[to_dir_id]
670
 
        else:
671
 
            update_inventory = False
672
 
 
673
 
        rollbacks = []
674
 
        def move_one(old_entry, from_path_utf8, minikind, executable,
675
 
                     fingerprint, packed_stat, size,
676
 
                     to_block, to_key, to_path_utf8):
677
 
            state._make_absent(old_entry)
678
 
            from_key = old_entry[0]
679
 
            rollbacks.append(
680
 
                lambda:state.update_minimal(from_key,
681
 
                    minikind,
682
 
                    executable=executable,
683
 
                    fingerprint=fingerprint,
684
 
                    packed_stat=packed_stat,
685
 
                    size=size,
686
 
                    path_utf8=from_path_utf8))
687
 
            state.update_minimal(to_key,
688
 
                    minikind,
689
 
                    executable=executable,
690
 
                    fingerprint=fingerprint,
691
 
                    packed_stat=packed_stat,
692
 
                    size=size,
693
 
                    path_utf8=to_path_utf8)
694
 
            added_entry_index, _ = state._find_entry_index(to_key, to_block[1])
695
 
            new_entry = to_block[1][added_entry_index]
696
 
            rollbacks.append(lambda:state._make_absent(new_entry))
697
 
 
698
 
        for from_rel in from_paths:
699
 
            # from_rel is 'pathinroot/foo/bar'
700
 
            from_rel_utf8 = from_rel.encode('utf8')
701
 
            from_dirname, from_tail = osutils.split(from_rel)
702
 
            from_dirname, from_tail_utf8 = osutils.split(from_rel_utf8)
703
 
            from_entry = self._get_entry(path=from_rel)
704
 
            if from_entry == (None, None):
705
 
                raise errors.BzrMoveFailedError(from_rel,to_dir,
706
 
                    errors.NotVersionedError(path=from_rel))
707
 
 
708
 
            from_id = from_entry[0][2]
709
 
            to_rel = pathjoin(to_dir, from_tail)
710
 
            to_rel_utf8 = pathjoin(to_dir_utf8, from_tail_utf8)
711
 
            item_to_entry = self._get_entry(path=to_rel)
712
 
            if item_to_entry != (None, None):
713
 
                raise errors.BzrMoveFailedError(from_rel, to_rel,
714
 
                    "Target is already versioned.")
715
 
 
716
 
            if from_rel == to_rel:
717
 
                raise errors.BzrMoveFailedError(from_rel, to_rel,
718
 
                    "Source and target are identical.")
719
 
 
720
 
            from_missing = not self.has_filename(from_rel)
721
 
            to_missing = not self.has_filename(to_rel)
722
 
            if after:
723
 
                move_file = False
724
 
            else:
725
 
                move_file = True
726
 
            if to_missing:
727
 
                if not move_file:
728
 
                    raise errors.BzrMoveFailedError(from_rel, to_rel,
729
 
                        errors.NoSuchFile(path=to_rel,
730
 
                        extra="New file has not been created yet"))
731
 
                elif from_missing:
732
 
                    # neither path exists
733
 
                    raise errors.BzrRenameFailedError(from_rel, to_rel,
734
 
                        errors.PathsDoNotExist(paths=(from_rel, to_rel)))
735
 
            else:
736
 
                if from_missing: # implicitly just update our path mapping
 
661
        with self.lock_tree_write():
 
662
            state = self.current_dirstate()
 
663
            if isinstance(from_paths, (str, bytes)):
 
664
                raise ValueError()
 
665
            to_dir_utf8 = to_dir.encode('utf8')
 
666
            to_entry_dirname, to_basename = os.path.split(to_dir_utf8)
 
667
            # check destination directory
 
668
            # get the details for it
 
669
            (to_entry_block_index, to_entry_entry_index, dir_present,
 
670
             entry_present) = state._get_block_entry_index(
 
671
                 to_entry_dirname, to_basename, 0)
 
672
            if not entry_present:
 
673
                raise errors.BzrMoveFailedError(
 
674
                    '', to_dir, errors.NotVersionedError(to_dir))
 
675
            to_entry = state._dirblocks[to_entry_block_index][1][to_entry_entry_index]
 
676
            # get a handle on the block itself.
 
677
            to_block_index = state._ensure_block(
 
678
                to_entry_block_index, to_entry_entry_index, to_dir_utf8)
 
679
            to_block = state._dirblocks[to_block_index]
 
680
            to_abs = self.abspath(to_dir)
 
681
            if not isdir(to_abs):
 
682
                raise errors.BzrMoveFailedError('', to_dir,
 
683
                                                errors.NotADirectory(to_abs))
 
684
 
 
685
            if to_entry[1][0][0] != b'd':
 
686
                raise errors.BzrMoveFailedError('', to_dir,
 
687
                                                errors.NotADirectory(to_abs))
 
688
 
 
689
            if self._inventory is not None:
 
690
                update_inventory = True
 
691
                inv = self.root_inventory
 
692
                to_dir_id = to_entry[0][2]
 
693
            else:
 
694
                update_inventory = False
 
695
 
 
696
            # GZ 2017-03-28: The rollbacks variable was shadowed in the loop below
 
697
            # missing those added here, but there's also no test coverage for this.
 
698
            rollbacks = contextlib.ExitStack()
 
699
 
 
700
            def move_one(old_entry, from_path_utf8, minikind, executable,
 
701
                         fingerprint, packed_stat, size,
 
702
                         to_block, to_key, to_path_utf8):
 
703
                state._make_absent(old_entry)
 
704
                from_key = old_entry[0]
 
705
                rollbacks.callback(
 
706
                    state.update_minimal,
 
707
                    from_key,
 
708
                    minikind,
 
709
                    executable=executable,
 
710
                    fingerprint=fingerprint,
 
711
                    packed_stat=packed_stat,
 
712
                    size=size,
 
713
                    path_utf8=from_path_utf8)
 
714
                state.update_minimal(to_key,
 
715
                                     minikind,
 
716
                                     executable=executable,
 
717
                                     fingerprint=fingerprint,
 
718
                                     packed_stat=packed_stat,
 
719
                                     size=size,
 
720
                                     path_utf8=to_path_utf8)
 
721
                added_entry_index, _ = state._find_entry_index(
 
722
                    to_key, to_block[1])
 
723
                new_entry = to_block[1][added_entry_index]
 
724
                rollbacks.callback(state._make_absent, new_entry)
 
725
 
 
726
            for from_rel in from_paths:
 
727
                # from_rel is 'pathinroot/foo/bar'
 
728
                from_rel_utf8 = from_rel.encode('utf8')
 
729
                from_dirname, from_tail = osutils.split(from_rel)
 
730
                from_dirname, from_tail_utf8 = osutils.split(from_rel_utf8)
 
731
                from_entry = self._get_entry(path=from_rel)
 
732
                if from_entry == (None, None):
 
733
                    raise errors.BzrMoveFailedError(
 
734
                        from_rel, to_dir,
 
735
                        errors.NotVersionedError(path=from_rel))
 
736
 
 
737
                from_id = from_entry[0][2]
 
738
                to_rel = pathjoin(to_dir, from_tail)
 
739
                to_rel_utf8 = pathjoin(to_dir_utf8, from_tail_utf8)
 
740
                item_to_entry = self._get_entry(path=to_rel)
 
741
                if item_to_entry != (None, None):
 
742
                    raise errors.BzrMoveFailedError(
 
743
                        from_rel, to_rel, "Target is already versioned.")
 
744
 
 
745
                if from_rel == to_rel:
 
746
                    raise errors.BzrMoveFailedError(
 
747
                        from_rel, to_rel, "Source and target are identical.")
 
748
 
 
749
                from_missing = not self.has_filename(from_rel)
 
750
                to_missing = not self.has_filename(to_rel)
 
751
                if after:
737
752
                    move_file = False
738
 
                elif not after:
739
 
                    raise errors.RenameFailedFilesExist(from_rel, to_rel)
 
753
                else:
 
754
                    move_file = True
 
755
                if to_missing:
 
756
                    if not move_file:
 
757
                        raise errors.BzrMoveFailedError(
 
758
                            from_rel, to_rel,
 
759
                            errors.NoSuchFile(
 
760
                                path=to_rel,
 
761
                                extra="New file has not been created yet"))
 
762
                    elif from_missing:
 
763
                        # neither path exists
 
764
                        raise errors.BzrRenameFailedError(
 
765
                            from_rel, to_rel,
 
766
                            errors.PathsDoNotExist(paths=(from_rel, to_rel)))
 
767
                else:
 
768
                    if from_missing:  # implicitly just update our path mapping
 
769
                        move_file = False
 
770
                    elif not after:
 
771
                        raise errors.RenameFailedFilesExist(from_rel, to_rel)
740
772
 
741
 
            rollbacks = []
742
 
            def rollback_rename():
743
 
                """A single rename has failed, roll it back."""
744
 
                # roll back everything, even if we encounter trouble doing one
745
 
                # of them.
746
 
                #
747
 
                # TODO: at least log the other exceptions rather than just
748
 
                # losing them mbp 20070307
749
 
                exc_info = None
750
 
                for rollback in reversed(rollbacks):
 
773
                # perform the disk move first - its the most likely failure point.
 
774
                if move_file:
 
775
                    from_rel_abs = self.abspath(from_rel)
 
776
                    to_rel_abs = self.abspath(to_rel)
751
777
                    try:
752
 
                        rollback()
753
 
                    except Exception, e:
754
 
                        exc_info = sys.exc_info()
755
 
                if exc_info:
756
 
                    raise exc_info[0], exc_info[1], exc_info[2]
757
 
 
758
 
            # perform the disk move first - its the most likely failure point.
759
 
            if move_file:
760
 
                from_rel_abs = self.abspath(from_rel)
761
 
                to_rel_abs = self.abspath(to_rel)
 
778
                        osutils.rename(from_rel_abs, to_rel_abs)
 
779
                    except OSError as e:
 
780
                        raise errors.BzrMoveFailedError(from_rel, to_rel, e[1])
 
781
                    rollbacks.callback(
 
782
                        osutils.rename, to_rel_abs, from_rel_abs)
762
783
                try:
763
 
                    osutils.rename(from_rel_abs, to_rel_abs)
764
 
                except OSError, e:
765
 
                    raise errors.BzrMoveFailedError(from_rel, to_rel, e[1])
766
 
                rollbacks.append(lambda: osutils.rename(to_rel_abs, from_rel_abs))
767
 
            try:
768
 
                # perform the rename in the inventory next if needed: its easy
769
 
                # to rollback
770
 
                if update_inventory:
771
 
                    # rename the entry
772
 
                    from_entry = inv[from_id]
773
 
                    current_parent = from_entry.parent_id
774
 
                    inv.rename(from_id, to_dir_id, from_tail)
775
 
                    rollbacks.append(
776
 
                        lambda: inv.rename(from_id, current_parent, from_tail))
777
 
                # finally do the rename in the dirstate, which is a little
778
 
                # tricky to rollback, but least likely to need it.
779
 
                old_block_index, old_entry_index, dir_present, file_present = \
780
 
                    state._get_block_entry_index(from_dirname, from_tail_utf8, 0)
781
 
                old_block = state._dirblocks[old_block_index][1]
782
 
                old_entry = old_block[old_entry_index]
783
 
                from_key, old_entry_details = old_entry
784
 
                cur_details = old_entry_details[0]
785
 
                # remove the old row
786
 
                to_key = ((to_block[0],) + from_key[1:3])
787
 
                minikind = cur_details[0]
788
 
                move_one(old_entry, from_path_utf8=from_rel_utf8,
789
 
                         minikind=minikind,
790
 
                         executable=cur_details[3],
791
 
                         fingerprint=cur_details[1],
792
 
                         packed_stat=cur_details[4],
793
 
                         size=cur_details[2],
794
 
                         to_block=to_block,
795
 
                         to_key=to_key,
796
 
                         to_path_utf8=to_rel_utf8)
797
 
 
798
 
                if minikind == 'd':
799
 
                    def update_dirblock(from_dir, to_key, to_dir_utf8):
800
 
                        """Recursively update all entries in this dirblock."""
801
 
                        if from_dir == '':
802
 
                            raise AssertionError("renaming root not supported")
803
 
                        from_key = (from_dir, '')
804
 
                        from_block_idx, present = \
805
 
                            state._find_block_index_from_key(from_key)
806
 
                        if not present:
807
 
                            # This is the old record, if it isn't present, then
808
 
                            # there is theoretically nothing to update.
809
 
                            # (Unless it isn't present because of lazy loading,
810
 
                            # but we don't do that yet)
811
 
                            return
812
 
                        from_block = state._dirblocks[from_block_idx]
813
 
                        to_block_index, to_entry_index, _, _ = \
814
 
                            state._get_block_entry_index(to_key[0], to_key[1], 0)
815
 
                        to_block_index = state._ensure_block(
816
 
                            to_block_index, to_entry_index, to_dir_utf8)
817
 
                        to_block = state._dirblocks[to_block_index]
818
 
 
819
 
                        # Grab a copy since move_one may update the list.
820
 
                        for entry in from_block[1][:]:
821
 
                            if not (entry[0][0] == from_dir):
822
 
                                raise AssertionError()
823
 
                            cur_details = entry[1][0]
824
 
                            to_key = (to_dir_utf8, entry[0][1], entry[0][2])
825
 
                            from_path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
826
 
                            to_path_utf8 = osutils.pathjoin(to_dir_utf8, entry[0][1])
827
 
                            minikind = cur_details[0]
828
 
                            if minikind in 'ar':
829
 
                                # Deleted children of a renamed directory
830
 
                                # Do not need to be updated.
831
 
                                # Children that have been renamed out of this
832
 
                                # directory should also not be updated
833
 
                                continue
834
 
                            move_one(entry, from_path_utf8=from_path_utf8,
835
 
                                     minikind=minikind,
836
 
                                     executable=cur_details[3],
837
 
                                     fingerprint=cur_details[1],
838
 
                                     packed_stat=cur_details[4],
839
 
                                     size=cur_details[2],
840
 
                                     to_block=to_block,
841
 
                                     to_key=to_key,
842
 
                                     to_path_utf8=to_path_utf8)
843
 
                            if minikind == 'd':
844
 
                                # We need to move all the children of this
845
 
                                # entry
846
 
                                update_dirblock(from_path_utf8, to_key,
847
 
                                                to_path_utf8)
848
 
                    update_dirblock(from_rel_utf8, to_key, to_rel_utf8)
849
 
            except:
850
 
                rollback_rename()
851
 
                raise
852
 
            result.append((from_rel, to_rel))
853
 
            state._dirblock_state = dirstate.DirState.IN_MEMORY_MODIFIED
854
 
            self._make_dirty(reset_inventory=False)
855
 
 
856
 
        return result
 
784
                    # perform the rename in the inventory next if needed: its easy
 
785
                    # to rollback
 
786
                    if update_inventory:
 
787
                        # rename the entry
 
788
                        from_entry = inv.get_entry(from_id)
 
789
                        current_parent = from_entry.parent_id
 
790
                        inv.rename(from_id, to_dir_id, from_tail)
 
791
                        rollbacks.callback(
 
792
                            inv.rename, from_id, current_parent, from_tail)
 
793
                    # finally do the rename in the dirstate, which is a little
 
794
                    # tricky to rollback, but least likely to need it.
 
795
                    old_block_index, old_entry_index, dir_present, file_present = \
 
796
                        state._get_block_entry_index(
 
797
                            from_dirname, from_tail_utf8, 0)
 
798
                    old_block = state._dirblocks[old_block_index][1]
 
799
                    old_entry = old_block[old_entry_index]
 
800
                    from_key, old_entry_details = old_entry
 
801
                    cur_details = old_entry_details[0]
 
802
                    # remove the old row
 
803
                    to_key = ((to_block[0],) + from_key[1:3])
 
804
                    minikind = cur_details[0]
 
805
                    move_one(old_entry, from_path_utf8=from_rel_utf8,
 
806
                             minikind=minikind,
 
807
                             executable=cur_details[3],
 
808
                             fingerprint=cur_details[1],
 
809
                             packed_stat=cur_details[4],
 
810
                             size=cur_details[2],
 
811
                             to_block=to_block,
 
812
                             to_key=to_key,
 
813
                             to_path_utf8=to_rel_utf8)
 
814
 
 
815
                    if minikind == b'd':
 
816
                        def update_dirblock(from_dir, to_key, to_dir_utf8):
 
817
                            """Recursively update all entries in this dirblock."""
 
818
                            if from_dir == b'':
 
819
                                raise AssertionError(
 
820
                                    "renaming root not supported")
 
821
                            from_key = (from_dir, '')
 
822
                            from_block_idx, present = \
 
823
                                state._find_block_index_from_key(from_key)
 
824
                            if not present:
 
825
                                # This is the old record, if it isn't present,
 
826
                                # then there is theoretically nothing to
 
827
                                # update.  (Unless it isn't present because of
 
828
                                # lazy loading, but we don't do that yet)
 
829
                                return
 
830
                            from_block = state._dirblocks[from_block_idx]
 
831
                            to_block_index, to_entry_index, _, _ = \
 
832
                                state._get_block_entry_index(
 
833
                                    to_key[0], to_key[1], 0)
 
834
                            to_block_index = state._ensure_block(
 
835
                                to_block_index, to_entry_index, to_dir_utf8)
 
836
                            to_block = state._dirblocks[to_block_index]
 
837
 
 
838
                            # Grab a copy since move_one may update the list.
 
839
                            for entry in from_block[1][:]:
 
840
                                if not (entry[0][0] == from_dir):
 
841
                                    raise AssertionError()
 
842
                                cur_details = entry[1][0]
 
843
                                to_key = (
 
844
                                    to_dir_utf8, entry[0][1], entry[0][2])
 
845
                                from_path_utf8 = osutils.pathjoin(
 
846
                                    entry[0][0], entry[0][1])
 
847
                                to_path_utf8 = osutils.pathjoin(
 
848
                                    to_dir_utf8, entry[0][1])
 
849
                                minikind = cur_details[0]
 
850
                                if minikind in (b'a', b'r'):
 
851
                                    # Deleted children of a renamed directory
 
852
                                    # Do not need to be updated.  Children that
 
853
                                    # have been renamed out of this directory
 
854
                                    # should also not be updated
 
855
                                    continue
 
856
                                move_one(entry, from_path_utf8=from_path_utf8,
 
857
                                         minikind=minikind,
 
858
                                         executable=cur_details[3],
 
859
                                         fingerprint=cur_details[1],
 
860
                                         packed_stat=cur_details[4],
 
861
                                         size=cur_details[2],
 
862
                                         to_block=to_block,
 
863
                                         to_key=to_key,
 
864
                                         to_path_utf8=to_path_utf8)
 
865
                                if minikind == b'd':
 
866
                                    # We need to move all the children of this
 
867
                                    # entry
 
868
                                    update_dirblock(from_path_utf8, to_key,
 
869
                                                    to_path_utf8)
 
870
                        update_dirblock(from_rel_utf8, to_key, to_rel_utf8)
 
871
                except BaseException:
 
872
                    rollbacks.close()
 
873
                    raise
 
874
                result.append((from_rel, to_rel))
 
875
                state._mark_modified()
 
876
                self._make_dirty(reset_inventory=False)
 
877
 
 
878
            return result
857
879
 
858
880
    def _must_be_locked(self):
859
881
        if not self._control_files._lock_count:
863
885
        """Initialize the state in this tree to be a new tree."""
864
886
        self._dirty = True
865
887
 
866
 
    @needs_read_lock
867
888
    def path2id(self, path):
868
889
        """Return the id for path in this tree."""
869
 
        path = path.strip('/')
870
 
        entry = self._get_entry(path=path)
871
 
        if entry == (None, None):
872
 
            return None
873
 
        return entry[0][2]
 
890
        with self.lock_read():
 
891
            if isinstance(path, list):
 
892
                if path == []:
 
893
                    path = [""]
 
894
                path = osutils.pathjoin(*path)
 
895
            path = path.strip('/')
 
896
            entry = self._get_entry(path=path)
 
897
            if entry == (None, None):
 
898
                nested_tree, subpath = self.get_containing_nested_tree(path)
 
899
                if nested_tree is not None:
 
900
                    return nested_tree.path2id(subpath)
 
901
                return None
 
902
            return entry[0][2]
874
903
 
875
904
    def paths2ids(self, paths, trees=[], require_versioned=True):
876
905
        """See Tree.paths2ids().
882
911
            return None
883
912
        parents = self.get_parent_ids()
884
913
        for tree in trees:
885
 
            if not (isinstance(tree, DirStateRevisionTree) and tree._revision_id in
886
 
                parents):
887
 
                return super(DirStateWorkingTree, self).paths2ids(paths,
888
 
                    trees, require_versioned)
889
 
        search_indexes = [0] + [1 + parents.index(tree._revision_id) for tree in trees]
890
 
        # -- make all paths utf8 --
 
914
            if not (isinstance(tree, DirStateRevisionTree) and
 
915
                    tree._revision_id in parents):
 
916
                return super(DirStateWorkingTree, self).paths2ids(
 
917
                    paths, trees, require_versioned)
 
918
        search_indexes = [
 
919
            0] + [1 + parents.index(tree._revision_id) for tree in trees]
891
920
        paths_utf8 = set()
892
921
        for path in paths:
893
922
            paths_utf8.add(path.encode('utf8'))
894
 
        paths = paths_utf8
895
 
        # -- paths is now a utf8 path set --
896
923
        # -- get the state object and prepare it.
897
924
        state = self.current_dirstate()
898
925
        if False and (state._dirblock_state == dirstate.DirState.NOT_IN_MEMORY
899
 
            and '' not in paths):
 
926
                      and b'' not in paths):
900
927
            paths2ids = self._paths2ids_using_bisect
901
928
        else:
902
929
            paths2ids = self._paths2ids_in_memory
903
 
        return paths2ids(paths, search_indexes,
 
930
        return paths2ids(paths_utf8, search_indexes,
904
931
                         require_versioned=require_versioned)
905
932
 
906
933
    def _paths2ids_in_memory(self, paths, search_indexes,
907
934
                             require_versioned=True):
908
935
        state = self.current_dirstate()
909
936
        state._read_dirblocks_if_needed()
 
937
 
910
938
        def _entries_for_path(path):
911
939
            """Return a list with all the entries that match path for all ids.
912
940
            """
913
941
            dirname, basename = os.path.split(path)
914
 
            key = (dirname, basename, '')
 
942
            key = (dirname, basename, b'')
915
943
            block_index, present = state._find_block_index_from_key(key)
916
944
            if not present:
917
945
                # the block which should contain path is absent.
919
947
            result = []
920
948
            block = state._dirblocks[block_index][1]
921
949
            entry_index, _ = state._find_entry_index(key, block)
922
 
            # we may need to look at multiple entries at this path: walk while the paths match.
 
950
            # we may need to look at multiple entries at this path: walk while
 
951
            # the paths match.
923
952
            while (entry_index < len(block) and
924
 
                block[entry_index][0][0:2] == key[0:2]):
 
953
                   block[entry_index][0][0:2] == key[0:2]):
925
954
                result.append(block[entry_index])
926
955
                entry_index += 1
927
956
            return result
939
968
                for entry in path_entries:
940
969
                    # for each tree.
941
970
                    for index in search_indexes:
942
 
                        if entry[1][index][0] != 'a': # absent
 
971
                        if entry[1][index][0] != b'a':  # absent
943
972
                            found_versioned = True
944
973
                            # all good: found a versioned cell
945
974
                            break
949
978
                    all_versioned = False
950
979
                    break
951
980
            if not all_versioned:
952
 
                raise errors.PathsNotVersionedError(paths)
 
981
                raise errors.PathsNotVersionedError(
 
982
                    [p.decode('utf-8') for p in paths])
953
983
        # -- remove redundancy in supplied paths to prevent over-scanning --
954
984
        search_paths = osutils.minimum_path_selection(paths)
955
985
        # sketch:
959
989
        # detail is not relocated, add the id.
960
990
        searched_paths = set()
961
991
        found_ids = set()
 
992
 
962
993
        def _process_entry(entry):
963
994
            """Look at search_indexes within entry.
964
995
 
967
998
            nothing. Otherwise add the id to found_ids.
968
999
            """
969
1000
            for index in search_indexes:
970
 
                if entry[1][index][0] == 'r': # relocated
971
 
                    if not osutils.is_inside_any(searched_paths, entry[1][index][1]):
 
1001
                if entry[1][index][0] == b'r':  # relocated
 
1002
                    if not osutils.is_inside_any(searched_paths,
 
1003
                                                 entry[1][index][1]):
972
1004
                        search_paths.add(entry[1][index][1])
973
 
                elif entry[1][index][0] != 'a': # absent
 
1005
                elif entry[1][index][0] != b'a':  # absent
974
1006
                    found_ids.add(entry[0][2])
975
1007
        while search_paths:
976
1008
            current_root = search_paths.pop()
977
1009
            searched_paths.add(current_root)
978
 
            # process the entries for this containing directory: the rest will be
979
 
            # found by their parents recursively.
 
1010
            # process the entries for this containing directory: the rest will
 
1011
            # be found by their parents recursively.
980
1012
            root_entries = _entries_for_path(current_root)
981
1013
            if not root_entries:
982
1014
                # this specified path is not present at all, skip it.
983
1015
                continue
984
1016
            for entry in root_entries:
985
1017
                _process_entry(entry)
986
 
            initial_key = (current_root, '', '')
 
1018
            initial_key = (current_root, b'', b'')
987
1019
            block_index, _ = state._find_block_index_from_key(initial_key)
988
1020
            while (block_index < len(state._dirblocks) and
989
 
                osutils.is_inside(current_root, state._dirblocks[block_index][0])):
 
1021
                   osutils.is_inside(current_root, state._dirblocks[block_index][0])):
990
1022
                for entry in state._dirblocks[block_index][1]:
991
1023
                    _process_entry(entry)
992
1024
                block_index += 1
1004
1036
            found_dir_names = set(dir_name_id[:2] for dir_name_id in found)
1005
1037
            for dir_name in split_paths:
1006
1038
                if dir_name not in found_dir_names:
1007
 
                    raise errors.PathsNotVersionedError(paths)
 
1039
                    raise errors.PathsNotVersionedError(
 
1040
                        [p.decode('utf-8') for p in paths])
1008
1041
 
1009
 
        for dir_name_id, trees_info in found.iteritems():
 
1042
        for dir_name_id, trees_info in found.items():
1010
1043
            for index in search_indexes:
1011
 
                if trees_info[index][0] not in ('r', 'a'):
 
1044
                if trees_info[index][0] not in (b'r', b'a'):
1012
1045
                    found_ids.add(dir_name_id[2])
1013
1046
        return found_ids
1014
1047
 
1017
1050
 
1018
1051
        This is a meaningless operation for dirstate, but we obey it anyhow.
1019
1052
        """
1020
 
        return self.inventory
 
1053
        return self.root_inventory
1021
1054
 
1022
 
    @needs_read_lock
1023
1055
    def revision_tree(self, revision_id):
1024
1056
        """See Tree.revision_tree.
1025
1057
 
1026
1058
        WorkingTree4 supplies revision_trees for any basis tree.
1027
1059
        """
1028
 
        dirstate = self.current_dirstate()
1029
 
        parent_ids = dirstate.get_parent_ids()
1030
 
        if revision_id not in parent_ids:
1031
 
            raise errors.NoSuchRevisionInTree(self, revision_id)
1032
 
        if revision_id in dirstate.get_ghosts():
1033
 
            raise errors.NoSuchRevisionInTree(self, revision_id)
1034
 
        return DirStateRevisionTree(dirstate, revision_id,
1035
 
            self.branch.repository)
 
1060
        with self.lock_read():
 
1061
            dirstate = self.current_dirstate()
 
1062
            parent_ids = dirstate.get_parent_ids()
 
1063
            if revision_id not in parent_ids:
 
1064
                raise errors.NoSuchRevisionInTree(self, revision_id)
 
1065
            if revision_id in dirstate.get_ghosts():
 
1066
                raise errors.NoSuchRevisionInTree(self, revision_id)
 
1067
            return DirStateRevisionTree(
 
1068
                dirstate, revision_id, self.branch.repository,
 
1069
                get_transport_from_path(self.basedir))
1036
1070
 
1037
 
    @needs_tree_write_lock
1038
1071
    def set_last_revision(self, new_revision):
1039
1072
        """Change the last revision in the working tree."""
1040
 
        parents = self.get_parent_ids()
1041
 
        if new_revision in (_mod_revision.NULL_REVISION, None):
1042
 
            if len(parents) >= 2:
1043
 
                raise AssertionError(
1044
 
                    "setting the last parent to none with a pending merge is "
1045
 
                    "unsupported.")
1046
 
            self.set_parent_ids([])
1047
 
        else:
1048
 
            self.set_parent_ids([new_revision] + parents[1:],
1049
 
                allow_leftmost_as_ghost=True)
 
1073
        with self.lock_tree_write():
 
1074
            parents = self.get_parent_ids()
 
1075
            if new_revision in (_mod_revision.NULL_REVISION, None):
 
1076
                if len(parents) >= 2:
 
1077
                    raise AssertionError(
 
1078
                        "setting the last parent to none with a pending merge "
 
1079
                        "is unsupported.")
 
1080
                self.set_parent_ids([])
 
1081
            else:
 
1082
                self.set_parent_ids(
 
1083
                    [new_revision] + parents[1:],
 
1084
                    allow_leftmost_as_ghost=True)
1050
1085
 
1051
 
    @needs_tree_write_lock
1052
1086
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
1053
1087
        """Set the parent ids to revision_ids.
1054
1088
 
1061
1095
        :param revision_ids: The revision_ids to set as the parent ids of this
1062
1096
            working tree. Any of these may be ghosts.
1063
1097
        """
1064
 
        trees = []
1065
 
        for revision_id in revision_ids:
1066
 
            try:
1067
 
                revtree = self.branch.repository.revision_tree(revision_id)
1068
 
                # TODO: jam 20070213 KnitVersionedFile raises
1069
 
                #       RevisionNotPresent rather than NoSuchRevision if a
1070
 
                #       given revision_id is not present. Should Repository be
1071
 
                #       catching it and re-raising NoSuchRevision?
1072
 
            except (errors.NoSuchRevision, errors.RevisionNotPresent):
1073
 
                revtree = None
1074
 
            trees.append((revision_id, revtree))
1075
 
        self.set_parent_trees(trees,
1076
 
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
1098
        with self.lock_tree_write():
 
1099
            trees = []
 
1100
            for revision_id in revision_ids:
 
1101
                try:
 
1102
                    revtree = self.branch.repository.revision_tree(revision_id)
 
1103
                    # TODO: jam 20070213 KnitVersionedFile raises
 
1104
                    # RevisionNotPresent rather than NoSuchRevision if a given
 
1105
                    # revision_id is not present. Should Repository be catching
 
1106
                    # it and re-raising NoSuchRevision?
 
1107
                except (errors.NoSuchRevision, errors.RevisionNotPresent):
 
1108
                    revtree = None
 
1109
                trees.append((revision_id, revtree))
 
1110
            self.set_parent_trees(
 
1111
                trees, allow_leftmost_as_ghost=allow_leftmost_as_ghost)
1077
1112
 
1078
 
    @needs_tree_write_lock
1079
1113
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
1080
1114
        """Set the parents of the working tree.
1081
1115
 
1083
1117
            If tree is None, then that element is treated as an unreachable
1084
1118
            parent tree - i.e. a ghost.
1085
1119
        """
1086
 
        dirstate = self.current_dirstate()
1087
 
        if len(parents_list) > 0:
1088
 
            if not allow_leftmost_as_ghost and parents_list[0][1] is None:
1089
 
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
1090
 
        real_trees = []
1091
 
        ghosts = []
1092
 
 
1093
 
        parent_ids = [rev_id for rev_id, tree in parents_list]
1094
 
        graph = self.branch.repository.get_graph()
1095
 
        heads = graph.heads(parent_ids)
1096
 
        accepted_revisions = set()
1097
 
 
1098
 
        # convert absent trees to the null tree, which we convert back to
1099
 
        # missing on access.
1100
 
        for rev_id, tree in parents_list:
1101
 
            if len(accepted_revisions) > 0:
1102
 
                # we always accept the first tree
1103
 
                if rev_id in accepted_revisions or rev_id not in heads:
1104
 
                    # We have already included either this tree, or its
1105
 
                    # descendent, so we skip it.
1106
 
                    continue
1107
 
            _mod_revision.check_not_reserved_id(rev_id)
1108
 
            if tree is not None:
1109
 
                real_trees.append((rev_id, tree))
1110
 
            else:
1111
 
                real_trees.append((rev_id,
1112
 
                    self.branch.repository.revision_tree(
1113
 
                        _mod_revision.NULL_REVISION)))
1114
 
                ghosts.append(rev_id)
1115
 
            accepted_revisions.add(rev_id)
1116
 
        dirstate.set_parent_trees(real_trees, ghosts=ghosts)
1117
 
        self._make_dirty(reset_inventory=False)
 
1120
        with self.lock_tree_write():
 
1121
            dirstate = self.current_dirstate()
 
1122
            if len(parents_list) > 0:
 
1123
                if not allow_leftmost_as_ghost and parents_list[0][1] is None:
 
1124
                    raise errors.GhostRevisionUnusableHere(parents_list[0][0])
 
1125
            real_trees = []
 
1126
            ghosts = []
 
1127
 
 
1128
            parent_ids = [rev_id for rev_id, tree in parents_list]
 
1129
            graph = self.branch.repository.get_graph()
 
1130
            heads = graph.heads(parent_ids)
 
1131
            accepted_revisions = set()
 
1132
 
 
1133
            # convert absent trees to the null tree, which we convert back to
 
1134
            # missing on access.
 
1135
            for rev_id, tree in parents_list:
 
1136
                if len(accepted_revisions) > 0:
 
1137
                    # we always accept the first tree
 
1138
                    if rev_id in accepted_revisions or rev_id not in heads:
 
1139
                        # We have already included either this tree, or its
 
1140
                        # descendent, so we skip it.
 
1141
                        continue
 
1142
                _mod_revision.check_not_reserved_id(rev_id)
 
1143
                if tree is not None:
 
1144
                    real_trees.append((rev_id, tree))
 
1145
                else:
 
1146
                    real_trees.append((rev_id,
 
1147
                                       self.branch.repository.revision_tree(
 
1148
                                           _mod_revision.NULL_REVISION)))
 
1149
                    ghosts.append(rev_id)
 
1150
                accepted_revisions.add(rev_id)
 
1151
            updated = False
 
1152
            if (len(real_trees) == 1
 
1153
                and not ghosts
 
1154
                and self.branch.repository._format.fast_deltas
 
1155
                and isinstance(real_trees[0][1], InventoryRevisionTree)
 
1156
                    and self.get_parent_ids()):
 
1157
                rev_id, rev_tree = real_trees[0]
 
1158
                basis_id = self.get_parent_ids()[0]
 
1159
                # There are times when basis_tree won't be in
 
1160
                # self.branch.repository, (switch, for example)
 
1161
                try:
 
1162
                    basis_tree = self.branch.repository.revision_tree(basis_id)
 
1163
                except errors.NoSuchRevision:
 
1164
                    # Fall back to the set_parent_trees(), since we can't use
 
1165
                    # _make_delta if we can't get the RevisionTree
 
1166
                    pass
 
1167
                else:
 
1168
                    delta = rev_tree.root_inventory._make_delta(
 
1169
                        basis_tree.root_inventory)
 
1170
                    dirstate.update_basis_by_delta(delta, rev_id)
 
1171
                    updated = True
 
1172
            if not updated:
 
1173
                dirstate.set_parent_trees(real_trees, ghosts=ghosts)
 
1174
            self._make_dirty(reset_inventory=False)
1118
1175
 
1119
1176
    def _set_root_id(self, file_id):
1120
1177
        """See WorkingTree.set_root_id."""
1121
1178
        state = self.current_dirstate()
1122
 
        state.set_path_id('', file_id)
 
1179
        state.set_path_id(b'', file_id)
1123
1180
        if state._dirblock_state == dirstate.DirState.IN_MEMORY_MODIFIED:
1124
1181
            self._make_dirty(reset_inventory=True)
1125
1182
 
1133
1190
        """
1134
1191
        return self.current_dirstate().sha1_from_stat(path, stat_result)
1135
1192
 
1136
 
    @needs_read_lock
1137
1193
    def supports_tree_reference(self):
1138
1194
        return self._repo_supports_tree_reference
1139
1195
 
1140
1196
    def unlock(self):
1141
1197
        """Unlock in format 4 trees needs to write the entire dirstate."""
1142
 
        # do non-implementation specific cleanup
1143
 
        self._cleanup()
1144
 
 
1145
1198
        if self._control_files._lock_count == 1:
 
1199
            # do non-implementation specific cleanup
 
1200
            self._cleanup()
 
1201
 
1146
1202
            # eventually we should do signature checking during read locks for
1147
1203
            # dirstate updates.
1148
1204
            if self._control_files._lock_mode == 'w':
1164
1220
        finally:
1165
1221
            self.branch.unlock()
1166
1222
 
1167
 
    @needs_tree_write_lock
1168
 
    def unversion(self, file_ids):
1169
 
        """Remove the file ids in file_ids from the current versioned set.
 
1223
    def unversion(self, paths):
 
1224
        """Remove the file ids in paths from the current versioned set.
1170
1225
 
1171
 
        When a file_id is unversioned, all of its children are automatically
 
1226
        When a directory is unversioned, all of its children are automatically
1172
1227
        unversioned.
1173
1228
 
1174
 
        :param file_ids: The file ids to stop versioning.
 
1229
        :param paths: The file ids to stop versioning.
1175
1230
        :raises: NoSuchId if any fileid is not currently versioned.
1176
1231
        """
1177
 
        if not file_ids:
1178
 
            return
1179
 
        state = self.current_dirstate()
1180
 
        state._read_dirblocks_if_needed()
1181
 
        ids_to_unversion = set(file_ids)
1182
 
        paths_to_unversion = set()
1183
 
        # sketch:
1184
 
        # check if the root is to be unversioned, if so, assert for now.
1185
 
        # walk the state marking unversioned things as absent.
1186
 
        # if there are any un-unversioned ids at the end, raise
1187
 
        for key, details in state._dirblocks[0][1]:
1188
 
            if (details[0][0] not in ('a', 'r') and # absent or relocated
1189
 
                key[2] in ids_to_unversion):
1190
 
                # I haven't written the code to unversion / yet - it should be
1191
 
                # supported.
1192
 
                raise errors.BzrError('Unversioning the / is not currently supported')
1193
 
        block_index = 0
1194
 
        while block_index < len(state._dirblocks):
1195
 
            # process one directory at a time.
1196
 
            block = state._dirblocks[block_index]
1197
 
            # first check: is the path one to remove - it or its children
1198
 
            delete_block = False
1199
 
            for path in paths_to_unversion:
1200
 
                if (block[0].startswith(path) and
1201
 
                    (len(block[0]) == len(path) or
1202
 
                     block[0][len(path)] == '/')):
1203
 
                    # this entire block should be deleted - its the block for a
1204
 
                    # path to unversion; or the child of one
1205
 
                    delete_block = True
1206
 
                    break
1207
 
            # TODO: trim paths_to_unversion as we pass by paths
1208
 
            if delete_block:
1209
 
                # this block is to be deleted: process it.
1210
 
                # TODO: we can special case the no-parents case and
1211
 
                # just forget the whole block.
 
1232
        with self.lock_tree_write():
 
1233
            if not paths:
 
1234
                return
 
1235
            state = self.current_dirstate()
 
1236
            state._read_dirblocks_if_needed()
 
1237
            file_ids = set()
 
1238
            for path in paths:
 
1239
                file_id = self.path2id(path)
 
1240
                if file_id is None:
 
1241
                    raise errors.NoSuchFile(self, path)
 
1242
                file_ids.add(file_id)
 
1243
            ids_to_unversion = set(file_ids)
 
1244
            paths_to_unversion = set()
 
1245
            # sketch:
 
1246
            # check if the root is to be unversioned, if so, assert for now.
 
1247
            # walk the state marking unversioned things as absent.
 
1248
            # if there are any un-unversioned ids at the end, raise
 
1249
            for key, details in state._dirblocks[0][1]:
 
1250
                if (details[0][0] not in (b'a', b'r') and  # absent or relocated
 
1251
                        key[2] in ids_to_unversion):
 
1252
                    # I haven't written the code to unversion / yet - it should
 
1253
                    # be supported.
 
1254
                    raise errors.BzrError(
 
1255
                        'Unversioning the / is not currently supported')
 
1256
            block_index = 0
 
1257
            while block_index < len(state._dirblocks):
 
1258
                # process one directory at a time.
 
1259
                block = state._dirblocks[block_index]
 
1260
                # first check: is the path one to remove - it or its children
 
1261
                delete_block = False
 
1262
                for path in paths_to_unversion:
 
1263
                    if (block[0].startswith(path) and
 
1264
                        (len(block[0]) == len(path) or
 
1265
                         block[0][len(path)] == '/')):
 
1266
                        # this entire block should be deleted - its the block for a
 
1267
                        # path to unversion; or the child of one
 
1268
                        delete_block = True
 
1269
                        break
 
1270
                # TODO: trim paths_to_unversion as we pass by paths
 
1271
                if delete_block:
 
1272
                    # this block is to be deleted: process it.
 
1273
                    # TODO: we can special case the no-parents case and
 
1274
                    # just forget the whole block.
 
1275
                    entry_index = 0
 
1276
                    while entry_index < len(block[1]):
 
1277
                        entry = block[1][entry_index]
 
1278
                        if entry[1][0][0] in (b'a', b'r'):
 
1279
                            # don't remove absent or renamed entries
 
1280
                            entry_index += 1
 
1281
                        else:
 
1282
                            # Mark this file id as having been removed
 
1283
                            ids_to_unversion.discard(entry[0][2])
 
1284
                            if not state._make_absent(entry):
 
1285
                                # The block has not shrunk.
 
1286
                                entry_index += 1
 
1287
                    # go to the next block. (At the moment we dont delete empty
 
1288
                    # dirblocks)
 
1289
                    block_index += 1
 
1290
                    continue
1212
1291
                entry_index = 0
1213
1292
                while entry_index < len(block[1]):
1214
1293
                    entry = block[1][entry_index]
1215
 
                    if entry[1][0][0] in 'ar':
1216
 
                        # don't remove absent or renamed entries
1217
 
                        entry_index += 1
1218
 
                    else:
1219
 
                        # Mark this file id as having been removed
1220
 
                        ids_to_unversion.discard(entry[0][2])
1221
 
                        if not state._make_absent(entry):
1222
 
                            # The block has not shrunk.
1223
 
                            entry_index += 1
1224
 
                # go to the next block. (At the moment we dont delete empty
1225
 
                # dirblocks)
 
1294
                    if (entry[1][0][0] in (b'a', b'r') or  # absent, relocated
 
1295
                        # ^ some parent row.
 
1296
                            entry[0][2] not in ids_to_unversion):
 
1297
                        # ^ not an id to unversion
 
1298
                        entry_index += 1
 
1299
                        continue
 
1300
                    if entry[1][0][0] == b'd':
 
1301
                        paths_to_unversion.add(
 
1302
                            pathjoin(entry[0][0], entry[0][1]))
 
1303
                    if not state._make_absent(entry):
 
1304
                        entry_index += 1
 
1305
                    # we have unversioned this id
 
1306
                    ids_to_unversion.remove(entry[0][2])
1226
1307
                block_index += 1
1227
 
                continue
1228
 
            entry_index = 0
1229
 
            while entry_index < len(block[1]):
1230
 
                entry = block[1][entry_index]
1231
 
                if (entry[1][0][0] in ('a', 'r') or # absent, relocated
1232
 
                    # ^ some parent row.
1233
 
                    entry[0][2] not in ids_to_unversion):
1234
 
                    # ^ not an id to unversion
1235
 
                    entry_index += 1
1236
 
                    continue
1237
 
                if entry[1][0][0] == 'd':
1238
 
                    paths_to_unversion.add(pathjoin(entry[0][0], entry[0][1]))
1239
 
                if not state._make_absent(entry):
1240
 
                    entry_index += 1
1241
 
                # we have unversioned this id
1242
 
                ids_to_unversion.remove(entry[0][2])
1243
 
            block_index += 1
1244
 
        if ids_to_unversion:
1245
 
            raise errors.NoSuchId(self, iter(ids_to_unversion).next())
1246
 
        self._make_dirty(reset_inventory=False)
1247
 
        # have to change the legacy inventory too.
1248
 
        if self._inventory is not None:
1249
 
            for file_id in file_ids:
1250
 
                self._inventory.remove_recursive_id(file_id)
 
1308
            if ids_to_unversion:
 
1309
                raise errors.NoSuchId(self, next(iter(ids_to_unversion)))
 
1310
            self._make_dirty(reset_inventory=False)
 
1311
            # have to change the legacy inventory too.
 
1312
            if self._inventory is not None:
 
1313
                for file_id in file_ids:
 
1314
                    if self._inventory.has_id(file_id):
 
1315
                        self._inventory.remove_recursive_id(file_id)
1251
1316
 
1252
 
    @needs_tree_write_lock
1253
1317
    def rename_one(self, from_rel, to_rel, after=False):
1254
1318
        """See WorkingTree.rename_one"""
1255
 
        self.flush()
1256
 
        WorkingTree.rename_one(self, from_rel, to_rel, after)
 
1319
        with self.lock_tree_write():
 
1320
            self.flush()
 
1321
            super(DirStateWorkingTree, self).rename_one(
 
1322
                from_rel, to_rel, after)
1257
1323
 
1258
 
    @needs_tree_write_lock
1259
1324
    def apply_inventory_delta(self, changes):
1260
1325
        """See MutableTree.apply_inventory_delta"""
1261
 
        state = self.current_dirstate()
1262
 
        state.update_by_delta(changes)
1263
 
        self._make_dirty(reset_inventory=True)
 
1326
        with self.lock_tree_write():
 
1327
            state = self.current_dirstate()
 
1328
            state.update_by_delta(changes)
 
1329
            self._make_dirty(reset_inventory=True)
1264
1330
 
1265
1331
    def update_basis_by_delta(self, new_revid, delta):
1266
1332
        """See MutableTree.update_basis_by_delta."""
1268
1334
            raise AssertionError()
1269
1335
        self.current_dirstate().update_basis_by_delta(delta, new_revid)
1270
1336
 
1271
 
    @needs_read_lock
1272
1337
    def _validate(self):
1273
 
        self._dirstate._validate()
 
1338
        with self.lock_read():
 
1339
            self._dirstate._validate()
1274
1340
 
1275
 
    @needs_tree_write_lock
1276
1341
    def _write_inventory(self, inv):
1277
1342
        """Write inventory as the current inventory."""
1278
1343
        if self._dirty:
1279
1344
            raise AssertionError("attempting to write an inventory when the "
1280
 
                "dirstate is dirty will lose pending changes")
1281
 
        had_inventory = self._inventory is not None
1282
 
        # Setting self._inventory = None forces the dirstate to regenerate the
1283
 
        # working inventory. We do this because self.inventory may be inv, or
1284
 
        # may have been modified, and either case would prevent a clean delta
1285
 
        # being created.
1286
 
        self._inventory = None
1287
 
        # generate a delta,
1288
 
        delta = inv._make_delta(self.inventory)
1289
 
        # and apply it.
1290
 
        self.apply_inventory_delta(delta)
1291
 
        if had_inventory:
1292
 
            self._inventory = inv
1293
 
        self.flush()
 
1345
                                 "dirstate is dirty will lose pending changes")
 
1346
        with self.lock_tree_write():
 
1347
            had_inventory = self._inventory is not None
 
1348
            # Setting self._inventory = None forces the dirstate to regenerate the
 
1349
            # working inventory. We do this because self.inventory may be inv, or
 
1350
            # may have been modified, and either case would prevent a clean delta
 
1351
            # being created.
 
1352
            self._inventory = None
 
1353
            # generate a delta,
 
1354
            delta = inv._make_delta(self.root_inventory)
 
1355
            # and apply it.
 
1356
            self.apply_inventory_delta(delta)
 
1357
            if had_inventory:
 
1358
                self._inventory = inv
 
1359
            self.flush()
 
1360
 
 
1361
    def reset_state(self, revision_ids=None):
 
1362
        """Reset the state of the working tree.
 
1363
 
 
1364
        This does a hard-reset to a last-known-good state. This is a way to
 
1365
        fix if something got corrupted (like the .bzr/checkout/dirstate file)
 
1366
        """
 
1367
        with self.lock_tree_write():
 
1368
            if revision_ids is None:
 
1369
                revision_ids = self.get_parent_ids()
 
1370
            if not revision_ids:
 
1371
                base_tree = self.branch.repository.revision_tree(
 
1372
                    _mod_revision.NULL_REVISION)
 
1373
                trees = []
 
1374
            else:
 
1375
                trees = list(zip(revision_ids,
 
1376
                                 self.branch.repository.revision_trees(revision_ids)))
 
1377
                base_tree = trees[0][1]
 
1378
            state = self.current_dirstate()
 
1379
            # We don't support ghosts yet
 
1380
            state.set_state_from_scratch(base_tree.root_inventory, trees, [])
1294
1381
 
1295
1382
 
1296
1383
class ContentFilterAwareSHA1Provider(dirstate.SHA1Provider):
1302
1389
        """See dirstate.SHA1Provider.sha1()."""
1303
1390
        filters = self.tree._content_filter_stack(
1304
1391
            self.tree.relpath(osutils.safe_unicode(abspath)))
1305
 
        return internal_size_sha_file_byname(abspath, filters)[1]
 
1392
        return _mod_filters.internal_size_sha_file_byname(abspath, filters)[1]
1306
1393
 
1307
1394
    def stat_and_sha1(self, abspath):
1308
1395
        """See dirstate.SHA1Provider.stat_and_sha1()."""
1309
1396
        filters = self.tree._content_filter_stack(
1310
1397
            self.tree.relpath(osutils.safe_unicode(abspath)))
1311
 
        file_obj = file(abspath, 'rb', 65000)
1312
 
        try:
 
1398
        with open(abspath, 'rb', 65000) as file_obj:
1313
1399
            statvalue = os.fstat(file_obj.fileno())
1314
1400
            if filters:
1315
 
                file_obj = filtered_input_file(file_obj, filters)
 
1401
                file_obj, size = _mod_filters.filtered_input_file(file_obj, filters)
 
1402
                statvalue = _mod_filters.FilteredStat(statvalue, size)
1316
1403
            sha1 = osutils.size_sha_file(file_obj)[1]
1317
 
        finally:
1318
 
            file_obj.close()
1319
1404
        return statvalue, sha1
1320
1405
 
1321
1406
 
1322
1407
class ContentFilteringDirStateWorkingTree(DirStateWorkingTree):
1323
1408
    """Dirstate working tree that supports content filtering.
1324
1409
 
1325
 
    The dirstate holds the hash and size of the canonical form of the file, 
 
1410
    The dirstate holds the hash and size of the canonical form of the file,
1326
1411
    and most methods must return that.
1327
1412
    """
1328
1413
 
1329
1414
    def _file_content_summary(self, path, stat_result):
1330
1415
        # This is to support the somewhat obsolete path_content_summary method
1331
1416
        # with content filtering: see
1332
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/415508>.
 
1417
        # <https://bugs.launchpad.net/bzr/+bug/415508>.
1333
1418
        #
1334
1419
        # If the dirstate cache is up to date and knows the hash and size,
1335
1420
        # return that.
1348
1433
class WorkingTree4(DirStateWorkingTree):
1349
1434
    """This is the Format 4 working tree.
1350
1435
 
1351
 
    This differs from WorkingTree3 by:
 
1436
    This differs from WorkingTree by:
1352
1437
     - Having a consolidated internal dirstate, stored in a
1353
1438
       randomly-accessible sorted file on disk.
1354
1439
     - Not having a regular inventory attribute.  One can be synthesized
1382
1467
        return views.PathBasedViews(self)
1383
1468
 
1384
1469
 
1385
 
class DirStateWorkingTreeFormat(WorkingTreeFormat3):
1386
 
 
1387
 
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
 
1470
class DirStateWorkingTreeFormat(WorkingTreeFormatMetaDir):
 
1471
 
 
1472
    missing_parent_conflicts = True
 
1473
 
 
1474
    supports_versioned_directories = True
 
1475
 
 
1476
    _lock_class = LockDir
 
1477
    _lock_file_name = 'lock'
 
1478
 
 
1479
    def _open_control_files(self, a_controldir):
 
1480
        transport = a_controldir.get_workingtree_transport(None)
 
1481
        return LockableFiles(transport, self._lock_file_name,
 
1482
                             self._lock_class)
 
1483
 
 
1484
    def initialize(self, a_controldir, revision_id=None, from_branch=None,
1388
1485
                   accelerator_tree=None, hardlink=False):
1389
1486
        """See WorkingTreeFormat.initialize().
1390
1487
 
1391
1488
        :param revision_id: allows creating a working tree at a different
1392
 
        revision than the branch is at.
 
1489
            revision than the branch is at.
1393
1490
        :param accelerator_tree: A tree which can be used for retrieving file
1394
1491
            contents more quickly than the revision tree, i.e. a workingtree.
1395
1492
            The revision tree will be used for cases where accelerator_tree's
1400
1497
        These trees get an initial random root id, if their repository supports
1401
1498
        rich root data, TREE_ROOT otherwise.
1402
1499
        """
1403
 
        if not isinstance(a_bzrdir.transport, LocalTransport):
1404
 
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
1405
 
        transport = a_bzrdir.get_workingtree_transport(self)
1406
 
        control_files = self._open_control_files(a_bzrdir)
 
1500
        if not isinstance(a_controldir.transport, LocalTransport):
 
1501
            raise errors.NotLocalUrl(a_controldir.transport.base)
 
1502
        transport = a_controldir.get_workingtree_transport(self)
 
1503
        control_files = self._open_control_files(a_controldir)
1407
1504
        control_files.create_lock()
1408
1505
        control_files.lock_write()
1409
 
        transport.put_bytes('format', self.get_format_string(),
1410
 
            mode=a_bzrdir._get_file_mode())
 
1506
        transport.put_bytes('format', self.as_string(),
 
1507
                            mode=a_controldir._get_file_mode())
1411
1508
        if from_branch is not None:
1412
1509
            branch = from_branch
1413
1510
        else:
1414
 
            branch = a_bzrdir.open_branch()
 
1511
            branch = a_controldir.open_branch()
1415
1512
        if revision_id is None:
1416
1513
            revision_id = branch.last_revision()
1417
1514
        local_path = transport.local_abspath('dirstate')
1419
1516
        state = dirstate.DirState.initialize(local_path)
1420
1517
        state.unlock()
1421
1518
        del state
1422
 
        wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
1423
 
                         branch,
1424
 
                         _format=self,
1425
 
                         _bzrdir=a_bzrdir,
1426
 
                         _control_files=control_files)
 
1519
        wt = self._tree_class(a_controldir.root_transport.local_abspath('.'),
 
1520
                              branch,
 
1521
                              _format=self,
 
1522
                              _controldir=a_controldir,
 
1523
                              _control_files=control_files)
1427
1524
        wt._new_tree()
1428
1525
        wt.lock_tree_write()
1429
1526
        try:
1449
1546
                parents_list = []
1450
1547
            else:
1451
1548
                parents_list = [(revision_id, basis)]
1452
 
            basis.lock_read()
1453
 
            try:
 
1549
            with basis.lock_read():
1454
1550
                wt.set_parent_trees(parents_list, allow_leftmost_as_ghost=True)
1455
1551
                wt.flush()
1456
1552
                # if the basis has a root id we have to use that; otherwise we
1457
1553
                # use a new random one
1458
 
                basis_root_id = basis.get_root_id()
 
1554
                basis_root_id = basis.path2id('')
1459
1555
                if basis_root_id is not None:
1460
1556
                    wt._set_root_id(basis_root_id)
1461
1557
                    wt.flush()
1472
1568
                transform.build_tree(basis, wt, accelerator_tree,
1473
1569
                                     hardlink=hardlink,
1474
1570
                                     delta_from_tree=delta_from_tree)
1475
 
            finally:
1476
 
                basis.unlock()
 
1571
                for hook in MutableTree.hooks['post_build_tree']:
 
1572
                    hook(wt)
1477
1573
        finally:
1478
1574
            control_files.unlock()
1479
1575
            wt.unlock()
1488
1584
        :param wt: the WorkingTree object
1489
1585
        """
1490
1586
 
1491
 
    def _open(self, a_bzrdir, control_files):
 
1587
    def open(self, a_controldir, _found=False):
 
1588
        """Return the WorkingTree object for a_controldir
 
1589
 
 
1590
        _found is a private parameter, do not use it. It is used to indicate
 
1591
               if format probing has already been done.
 
1592
        """
 
1593
        if not _found:
 
1594
            # we are being called directly and must probe.
 
1595
            raise NotImplementedError
 
1596
        if not isinstance(a_controldir.transport, LocalTransport):
 
1597
            raise errors.NotLocalUrl(a_controldir.transport.base)
 
1598
        wt = self._open(a_controldir, self._open_control_files(a_controldir))
 
1599
        return wt
 
1600
 
 
1601
    def _open(self, a_controldir, control_files):
1492
1602
        """Open the tree itself.
1493
1603
 
1494
 
        :param a_bzrdir: the dir for the tree.
 
1604
        :param a_controldir: the dir for the tree.
1495
1605
        :param control_files: the control files for the tree.
1496
1606
        """
1497
 
        return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
1498
 
                           branch=a_bzrdir.open_branch(),
1499
 
                           _format=self,
1500
 
                           _bzrdir=a_bzrdir,
1501
 
                           _control_files=control_files)
1502
 
 
1503
 
    def __get_matchingbzrdir(self):
1504
 
        return self._get_matchingbzrdir()
1505
 
 
1506
 
    def _get_matchingbzrdir(self):
 
1607
        return self._tree_class(a_controldir.root_transport.local_abspath('.'),
 
1608
                                branch=a_controldir.open_branch(),
 
1609
                                _format=self,
 
1610
                                _controldir=a_controldir,
 
1611
                                _control_files=control_files)
 
1612
 
 
1613
    def __get_matchingcontroldir(self):
 
1614
        return self._get_matchingcontroldir()
 
1615
 
 
1616
    def _get_matchingcontroldir(self):
1507
1617
        """Overrideable method to get a bzrdir for testing."""
1508
1618
        # please test against something that will let us do tree references
1509
 
        return bzrdir.format_registry.make_bzrdir(
1510
 
            'dirstate-with-subtree')
 
1619
        return controldir.format_registry.make_controldir(
 
1620
            'development-subtree')
1511
1621
 
1512
 
    _matchingbzrdir = property(__get_matchingbzrdir)
 
1622
    _matchingcontroldir = property(__get_matchingcontroldir)
1513
1623
 
1514
1624
 
1515
1625
class WorkingTreeFormat4(DirStateWorkingTreeFormat):
1518
1628
    This format:
1519
1629
        - exists within a metadir controlling .bzr
1520
1630
        - includes an explicit version marker for the workingtree control
1521
 
          files, separate from the BzrDir format
 
1631
          files, separate from the ControlDir format
1522
1632
        - modifies the hash cache format
1523
1633
        - is new in bzr 0.15
1524
1634
        - uses a LockDir to guard access to it.
1528
1638
 
1529
1639
    _tree_class = WorkingTree4
1530
1640
 
1531
 
    def get_format_string(self):
 
1641
    @classmethod
 
1642
    def get_format_string(cls):
1532
1643
        """See WorkingTreeFormat.get_format_string()."""
1533
 
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
 
1644
        return b"Bazaar Working Tree Format 4 (bzr 0.15)\n"
1534
1645
 
1535
1646
    def get_format_description(self):
1536
1647
        """See WorkingTreeFormat.get_format_description()."""
1545
1656
 
1546
1657
    _tree_class = WorkingTree5
1547
1658
 
1548
 
    def get_format_string(self):
 
1659
    @classmethod
 
1660
    def get_format_string(cls):
1549
1661
        """See WorkingTreeFormat.get_format_string()."""
1550
 
        return "Bazaar Working Tree Format 5 (bzr 1.11)\n"
 
1662
        return b"Bazaar Working Tree Format 5 (bzr 1.11)\n"
1551
1663
 
1552
1664
    def get_format_description(self):
1553
1665
        """See WorkingTreeFormat.get_format_description()."""
1565
1677
 
1566
1678
    _tree_class = WorkingTree6
1567
1679
 
1568
 
    def get_format_string(self):
 
1680
    @classmethod
 
1681
    def get_format_string(cls):
1569
1682
        """See WorkingTreeFormat.get_format_string()."""
1570
 
        return "Bazaar Working Tree Format 6 (bzr 1.14)\n"
 
1683
        return b"Bazaar Working Tree Format 6 (bzr 1.14)\n"
1571
1684
 
1572
1685
    def get_format_description(self):
1573
1686
        """See WorkingTreeFormat.get_format_description()."""
1575
1688
 
1576
1689
    def _init_custom_control_files(self, wt):
1577
1690
        """Subclasses with custom control files should override this method."""
1578
 
        wt._transport.put_bytes('views', '', mode=wt.bzrdir._get_file_mode())
 
1691
        wt._transport.put_bytes('views', b'',
 
1692
                                mode=wt.controldir._get_file_mode())
1579
1693
 
1580
1694
    def supports_content_filtering(self):
1581
1695
        return True
1583
1697
    def supports_views(self):
1584
1698
        return True
1585
1699
 
1586
 
 
1587
 
class DirStateRevisionTree(Tree):
 
1700
    def _get_matchingcontroldir(self):
 
1701
        """Overrideable method to get a bzrdir for testing."""
 
1702
        # We use 'development-subtree' instead of '2a', because we have a
 
1703
        # few tests that want to test tree references
 
1704
        return controldir.format_registry.make_controldir('development-subtree')
 
1705
 
 
1706
 
 
1707
class DirStateRevisionTree(InventoryTree):
1588
1708
    """A revision tree pulling the inventory from a dirstate.
1589
 
    
 
1709
 
1590
1710
    Note that this is one of the historical (ie revision) trees cached in the
1591
1711
    dirstate for easy access, not the workingtree.
1592
1712
    """
1593
1713
 
1594
 
    def __init__(self, dirstate, revision_id, repository):
 
1714
    def __init__(self, dirstate, revision_id, repository, nested_tree_transport):
1595
1715
        self._dirstate = dirstate
1596
1716
        self._revision_id = revision_id
1597
1717
        self._repository = repository
1598
1718
        self._inventory = None
1599
1719
        self._locked = 0
1600
1720
        self._dirstate_locked = False
 
1721
        self._nested_tree_transport = nested_tree_transport
1601
1722
        self._repo_supports_tree_reference = getattr(
1602
1723
            repository._format, "supports_tree_reference",
1603
1724
            False)
1606
1727
        return "<%s of %s in %s>" % \
1607
1728
            (self.__class__.__name__, self._revision_id, self._dirstate)
1608
1729
 
1609
 
    def annotate_iter(self, file_id,
 
1730
    def annotate_iter(self, path,
1610
1731
                      default_revision=_mod_revision.CURRENT_REVISION):
1611
1732
        """See Tree.annotate_iter"""
1612
 
        text_key = (file_id, self.inventory[file_id].revision)
 
1733
        file_id = self.path2id(path)
 
1734
        text_key = (file_id, self.get_file_revision(path))
1613
1735
        annotations = self._repository.texts.annotate(text_key)
1614
1736
        return [(key[-1], line) for (key, line) in annotations]
1615
1737
 
1616
 
    def _get_ancestors(self, default_revision):
1617
 
        return set(self._repository.get_ancestry(self._revision_id,
1618
 
                                                 topo_sorted=False))
1619
1738
    def _comparison_data(self, entry, path):
1620
1739
        """See Tree._comparison_data."""
1621
1740
        if entry is None:
1624
1743
        # sensible: the entry might not have come from us?
1625
1744
        return entry.kind, entry.executable, None
1626
1745
 
1627
 
    def _file_size(self, entry, stat_value):
1628
 
        return entry.text_size
 
1746
    def _get_file_revision(self, path, file_id, vf, tree_revision):
 
1747
        """Ensure that file_id, tree_revision is in vf to plan the merge."""
 
1748
        last_revision = self.get_file_revision(path)
 
1749
        base_vf = self._repository.texts
 
1750
        if base_vf not in vf.fallback_versionedfiles:
 
1751
            vf.fallback_versionedfiles.append(base_vf)
 
1752
        return last_revision
1629
1753
 
1630
1754
    def filter_unversioned_files(self, paths):
1631
1755
        """Filter out paths that are not versioned.
1635
1759
        pred = self.has_filename
1636
1760
        return set((p for p in paths if not pred(p)))
1637
1761
 
1638
 
    def get_root_id(self):
1639
 
        return self.path2id('')
1640
 
 
1641
 
    def id2path(self, file_id):
 
1762
    def id2path(self, file_id, recurse='down'):
1642
1763
        "Convert a file-id to a path."
1643
 
        entry = self._get_entry(file_id=file_id)
1644
 
        if entry == (None, None):
1645
 
            raise errors.NoSuchId(tree=self, file_id=file_id)
1646
 
        path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
1647
 
        return path_utf8.decode('utf8')
 
1764
        with self.lock_read():
 
1765
            entry = self._get_entry(file_id=file_id)
 
1766
            if entry == (None, None):
 
1767
                if recurse == 'down':
 
1768
                    if 'evil' in debug.debug_flags:
 
1769
                        trace.mutter_callsite(
 
1770
                            2, "Tree.id2path scans all nested trees.")
 
1771
 
 
1772
                    for nested_path in self.iter_references():
 
1773
                        nested_tree = self.get_nested_tree(nested_path)
 
1774
                        try:
 
1775
                            return osutils.pathjoin(nested_path, nested_tree.id2path(file_id))
 
1776
                        except errors.NoSuchId:
 
1777
                            pass
 
1778
                raise errors.NoSuchId(tree=self, file_id=file_id)
 
1779
            path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
 
1780
            return path_utf8.decode('utf8')
 
1781
 
 
1782
    def get_nested_tree(self, path):
 
1783
        with self.lock_read():
 
1784
            nested_revid = self.get_reference_revision(path)
 
1785
            return self._get_nested_tree(path, None, nested_revid)
 
1786
 
 
1787
    def _get_nested_tree(self, path, file_id, reference_revision):
 
1788
        branch = _mod_branch.Branch.open_from_transport(
 
1789
            self._nested_tree_transport.clone(path))
 
1790
        try:
 
1791
            revtree = branch.repository.revision_tree(reference_revision)
 
1792
        except errors.NoSuchRevision:
 
1793
            raise MissingNestedTree(path)
 
1794
        if file_id is not None and revtree.path2id('') != file_id:
 
1795
            raise AssertionError('mismatching file id: %r != %r' % (
 
1796
                revtree.path2id(''), file_id))
 
1797
        return revtree
1648
1798
 
1649
1799
    def iter_references(self):
1650
1800
        if not self._repo_supports_tree_reference:
1673
1823
            raise errors.BzrError('must supply file_id or path')
1674
1824
        if path is not None:
1675
1825
            path = path.encode('utf8')
1676
 
        parent_index = self._get_parent_index()
1677
 
        return self._dirstate._get_entry(parent_index, fileid_utf8=file_id, path_utf8=path)
 
1826
        try:
 
1827
            parent_index = self._get_parent_index()
 
1828
        except ValueError:
 
1829
            raise errors.NoSuchRevisionInTree(self._dirstate, self._revision_id)
 
1830
        return self._dirstate._get_entry(parent_index, fileid_utf8=file_id,
 
1831
                                         path_utf8=path)
1678
1832
 
1679
1833
    def _generate_inventory(self):
1680
1834
        """Create and set self.inventory from the dirstate object.
1693
1847
        if self._revision_id not in self._dirstate.get_parent_ids():
1694
1848
            raise AssertionError(
1695
1849
                'parent %s has disappeared from %s' % (
1696
 
                self._revision_id, self._dirstate.get_parent_ids()))
 
1850
                    self._revision_id, self._dirstate.get_parent_ids()))
1697
1851
        parent_index = self._dirstate.get_parent_ids().index(self._revision_id) + 1
1698
1852
        # This is identical now to the WorkingTree _generate_inventory except
1699
1853
        # for the tree index use.
1700
 
        root_key, current_entry = self._dirstate._get_entry(parent_index, path_utf8='')
 
1854
        root_key, current_entry = self._dirstate._get_entry(
 
1855
            parent_index, path_utf8=b'')
1701
1856
        current_id = root_key[2]
1702
 
        if current_entry[parent_index][0] != 'd':
 
1857
        if current_entry[parent_index][0] != b'd':
1703
1858
            raise AssertionError()
1704
1859
        inv = Inventory(root_id=current_id, revision_id=self._revision_id)
1705
1860
        inv.root.revision = current_entry[parent_index][4]
1710
1865
        inv_byid = inv._byid
1711
1866
        # we could do this straight out of the dirstate; it might be fast
1712
1867
        # and should be profiled - RBC 20070216
1713
 
        parent_ies = {'' : inv.root}
1714
 
        for block in self._dirstate._dirblocks[1:]: #skip root
 
1868
        parent_ies = {b'': inv.root}
 
1869
        for block in self._dirstate._dirblocks[1:]:  # skip root
1715
1870
            dirname = block[0]
1716
1871
            try:
1717
1872
                parent_ie = parent_ies[dirname]
1719
1874
                # all the paths in this block are not versioned in this tree
1720
1875
                continue
1721
1876
            for key, entry in block[1]:
1722
 
                minikind, fingerprint, size, executable, revid = entry[parent_index]
1723
 
                if minikind in ('a', 'r'): # absent, relocated
 
1877
                (minikind, fingerprint, size, executable,
 
1878
                 revid) = entry[parent_index]
 
1879
                if minikind in (b'a', b'r'):  # absent, relocated
1724
1880
                    # not this tree
1725
1881
                    continue
1726
1882
                name = key[1]
1735
1891
                    inv_entry.text_size = size
1736
1892
                    inv_entry.text_sha1 = fingerprint
1737
1893
                elif kind == 'directory':
1738
 
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
 
1894
                    parent_ies[(dirname + b'/' + name).strip(b'/')] = inv_entry
1739
1895
                elif kind == 'symlink':
1740
 
                    inv_entry.executable = False
1741
 
                    inv_entry.text_size = None
1742
1896
                    inv_entry.symlink_target = utf8_decode(fingerprint)[0]
1743
1897
                elif kind == 'tree-reference':
1744
1898
                    inv_entry.reference_revision = fingerprint or None
1745
1899
                else:
1746
 
                    raise AssertionError("cannot convert entry %r into an InventoryEntry"
1747
 
                            % entry)
 
1900
                    raise AssertionError(
 
1901
                        "cannot convert entry %r into an InventoryEntry"
 
1902
                        % entry)
1748
1903
                # These checks cost us around 40ms on a 55k entry tree
1749
1904
                if file_id in inv_byid:
1750
 
                    raise AssertionError('file_id %s already in'
 
1905
                    raise AssertionError(
 
1906
                        'file_id %s already in'
1751
1907
                        ' inventory as %s' % (file_id, inv_byid[file_id]))
1752
1908
                if name_unicode in parent_ie.children:
1753
1909
                    raise AssertionError('name %r already in parent'
1754
 
                        % (name_unicode,))
 
1910
                                         % (name_unicode,))
1755
1911
                inv_byid[file_id] = inv_entry
1756
1912
                parent_ie.children[name_unicode] = inv_entry
1757
1913
        self._inventory = inv
1758
1914
 
1759
 
    def get_file_mtime(self, file_id, path=None):
 
1915
    def get_file_mtime(self, path):
1760
1916
        """Return the modification time for this record.
1761
1917
 
1762
1918
        We return the timestamp of the last-changed revision.
1763
1919
        """
1764
1920
        # Make sure the file exists
1765
 
        entry = self._get_entry(file_id, path=path)
 
1921
        entry = self._get_entry(path=path)
1766
1922
        if entry == (None, None): # do we raise?
1767
 
            return None
 
1923
            raise errors.NoSuchFile(path)
1768
1924
        parent_index = self._get_parent_index()
1769
1925
        last_changed_revision = entry[1][parent_index][4]
1770
1926
        try:
1771
1927
            rev = self._repository.get_revision(last_changed_revision)
1772
1928
        except errors.NoSuchRevision:
1773
 
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
 
1929
            raise FileTimestampUnavailable(path)
1774
1930
        return rev.timestamp
1775
1931
 
1776
 
    def get_file_sha1(self, file_id, path=None, stat_value=None):
1777
 
        entry = self._get_entry(file_id=file_id, path=path)
 
1932
    def get_file_sha1(self, path, stat_value=None):
 
1933
        entry = self._get_entry(path=path)
1778
1934
        parent_index = self._get_parent_index()
1779
1935
        parent_details = entry[1][parent_index]
1780
 
        if parent_details[0] == 'f':
 
1936
        if parent_details[0] == b'f':
1781
1937
            return parent_details[1]
1782
1938
        return None
1783
1939
 
1784
 
    def get_file(self, file_id, path=None):
1785
 
        return StringIO(self.get_file_text(file_id))
1786
 
 
1787
 
    def get_file_size(self, file_id):
 
1940
    def get_file_revision(self, path):
 
1941
        with self.lock_read():
 
1942
            inv, inv_file_id = self._path2inv_file_id(path)
 
1943
            return inv.get_entry(inv_file_id).revision
 
1944
 
 
1945
    def get_file(self, path):
 
1946
        return BytesIO(self.get_file_text(path))
 
1947
 
 
1948
    def get_file_size(self, path):
1788
1949
        """See Tree.get_file_size"""
1789
 
        return self.inventory[file_id].text_size
1790
 
 
1791
 
    def get_file_text(self, file_id, path=None):
1792
 
        _, content = list(self.iter_files_bytes([(file_id, None)]))[0]
1793
 
        return ''.join(content)
1794
 
 
1795
 
    def get_reference_revision(self, file_id, path=None):
1796
 
        return self.inventory[file_id].reference_revision
 
1950
        inv, inv_file_id = self._path2inv_file_id(path)
 
1951
        return inv.get_entry(inv_file_id).text_size
 
1952
 
 
1953
    def get_file_text(self, path):
 
1954
        content = None
 
1955
        for _, content_iter in self.iter_files_bytes([(path, None)]):
 
1956
            if content is not None:
 
1957
                raise AssertionError('iter_files_bytes returned'
 
1958
                                     ' too many entries')
 
1959
            # For each entry returned by iter_files_bytes, we must consume the
 
1960
            # content_iter before we step the files iterator.
 
1961
            content = b''.join(content_iter)
 
1962
        if content is None:
 
1963
            raise AssertionError('iter_files_bytes did not return'
 
1964
                                 ' the requested data')
 
1965
        return content
 
1966
 
 
1967
    def get_reference_revision(self, path):
 
1968
        inv, inv_file_id = self._path2inv_file_id(path)
 
1969
        return inv.get_entry(inv_file_id).reference_revision
1797
1970
 
1798
1971
    def iter_files_bytes(self, desired_files):
1799
1972
        """See Tree.iter_files_bytes.
1801
1974
        This version is implemented on top of Repository.iter_files_bytes"""
1802
1975
        parent_index = self._get_parent_index()
1803
1976
        repo_desired_files = []
1804
 
        for file_id, identifier in desired_files:
1805
 
            entry = self._get_entry(file_id)
 
1977
        for path, identifier in desired_files:
 
1978
            entry = self._get_entry(path=path)
1806
1979
            if entry == (None, None):
1807
 
                raise errors.NoSuchId(self, file_id)
1808
 
            repo_desired_files.append((file_id, entry[1][parent_index][4],
 
1980
                raise errors.NoSuchFile(path)
 
1981
            repo_desired_files.append((entry[0][2], entry[1][parent_index][4],
1809
1982
                                       identifier))
1810
1983
        return self._repository.iter_files_bytes(repo_desired_files)
1811
1984
 
1812
 
    def get_symlink_target(self, file_id):
1813
 
        entry = self._get_entry(file_id=file_id)
 
1985
    def get_symlink_target(self, path):
 
1986
        entry = self._get_entry(path=path)
 
1987
        if entry is None:
 
1988
            raise errors.NoSuchFile(tree=self, path=path)
1814
1989
        parent_index = self._get_parent_index()
1815
 
        if entry[1][parent_index][0] != 'l':
 
1990
        if entry[1][parent_index][0] != b'l':
1816
1991
            return None
1817
1992
        else:
1818
1993
            target = entry[1][parent_index][1]
1823
1998
        """Return the revision id for this tree."""
1824
1999
        return self._revision_id
1825
2000
 
1826
 
    def _get_inventory(self):
 
2001
    def _get_root_inventory(self):
1827
2002
        if self._inventory is not None:
1828
2003
            return self._inventory
1829
2004
        self._must_be_locked()
1830
2005
        self._generate_inventory()
1831
2006
        return self._inventory
1832
2007
 
1833
 
    inventory = property(_get_inventory,
1834
 
                         doc="Inventory of this Tree")
 
2008
    root_inventory = property(_get_root_inventory,
 
2009
                              doc="Inventory of this Tree")
1835
2010
 
1836
2011
    def get_parent_ids(self):
1837
2012
        """The parents of a tree in the dirstate are not cached."""
1840
2015
    def has_filename(self, filename):
1841
2016
        return bool(self.path2id(filename))
1842
2017
 
1843
 
    def kind(self, file_id):
1844
 
        entry = self._get_entry(file_id=file_id)[1]
 
2018
    def kind(self, path):
 
2019
        entry = self._get_entry(path=path)[1]
1845
2020
        if entry is None:
1846
 
            raise errors.NoSuchId(tree=self, file_id=file_id)
 
2021
            raise errors.NoSuchFile(path)
1847
2022
        parent_index = self._get_parent_index()
1848
2023
        return dirstate.DirState._minikind_to_kind[entry[parent_index][0]]
1849
2024
 
1850
 
    def stored_kind(self, file_id):
 
2025
    def stored_kind(self, path):
1851
2026
        """See Tree.stored_kind"""
1852
 
        return self.kind(file_id)
 
2027
        return self.kind(path)
1853
2028
 
1854
2029
    def path_content_summary(self, path):
1855
2030
        """See Tree.path_content_summary."""
1856
 
        id = self.inventory.path2id(path)
1857
 
        if id is None:
 
2031
        inv, inv_file_id = self._path2inv_file_id(path)
 
2032
        if inv_file_id is None:
1858
2033
            return ('missing', None, None, None)
1859
 
        entry = self._inventory[id]
 
2034
        entry = inv.get_entry(inv_file_id)
1860
2035
        kind = entry.kind
1861
2036
        if kind == 'file':
1862
2037
            return (kind, entry.text_size, entry.executable, entry.text_sha1)
1865
2040
        else:
1866
2041
            return (kind, None, None, None)
1867
2042
 
1868
 
    def is_executable(self, file_id, path=None):
1869
 
        ie = self.inventory[file_id]
 
2043
    def is_executable(self, path):
 
2044
        inv, inv_file_id = self._path2inv_file_id(path)
 
2045
        if inv_file_id is None:
 
2046
            raise errors.NoSuchFile(path)
 
2047
        ie = inv.get_entry(inv_file_id)
1870
2048
        if ie.kind != "file":
1871
 
            return None
 
2049
            return False
1872
2050
        return ie.executable
1873
2051
 
1874
2052
    def is_locked(self):
1875
2053
        return self._locked
1876
2054
 
1877
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
1878
 
        # We use a standard implementation, because DirStateRevisionTree is
1879
 
        # dealing with one of the parents of the current state
1880
 
        inv = self._get_inventory()
 
2055
    def list_files(self, include_root=False, from_dir=None, recursive=True,
 
2056
                   recurse_nested=False):
 
2057
        # The only files returned by this are those from the version
1881
2058
        if from_dir is None:
1882
2059
            from_dir_id = None
 
2060
            inv = self.root_inventory
1883
2061
        else:
1884
 
            from_dir_id = inv.path2id(from_dir)
 
2062
            inv, from_dir_id = self._path2inv_file_id(from_dir)
1885
2063
            if from_dir_id is None:
1886
2064
                # Directory not versioned
1887
 
                return
1888
 
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
1889
 
        if inv.root is not None and not include_root and from_dir is None:
1890
 
            entries.next()
1891
 
        for path, entry in entries:
1892
 
            yield path, 'V', entry.kind, entry.file_id, entry
 
2065
                return iter([])
 
2066
        def iter_entries(inv):
 
2067
            entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
 
2068
            if inv.root is not None and not include_root and from_dir is None:
 
2069
                # skip the root for compatibility with the current apis.
 
2070
                next(entries)
 
2071
            for path, entry in entries:
 
2072
                if entry.kind == 'tree-reference' and recurse_nested:
 
2073
                    subtree = self._get_nested_tree(
 
2074
                        path, entry.file_id, entry.reference_revision)
 
2075
                    for subpath, status, kind, entry in subtree.list_files(
 
2076
                            include_root=True, recursive=recursive,
 
2077
                            recurse_nested=recurse_nested):
 
2078
                        if subpath:
 
2079
                            full_subpath = osutils.pathjoin(path, subpath)
 
2080
                        else:
 
2081
                            full_subpath = path
 
2082
                        yield full_subpath, status, kind, entry
 
2083
                else:
 
2084
                    yield path, 'V', entry.kind, entry
 
2085
        return iter_entries(inv)
1893
2086
 
1894
2087
    def lock_read(self):
1895
2088
        """Lock the tree for a set of operations.
1896
2089
 
1897
 
        :return: A bzrlib.lock.LogicalLockResult.
 
2090
        :return: A breezy.lock.LogicalLockResult.
1898
2091
        """
1899
2092
        if not self._locked:
1900
2093
            self._repository.lock_read()
1908
2101
        if not self._locked:
1909
2102
            raise errors.ObjectNotLocked(self)
1910
2103
 
1911
 
    @needs_read_lock
1912
2104
    def path2id(self, path):
1913
2105
        """Return the id for path in this tree."""
1914
2106
        # lookup by path: faster than splitting and walking the ivnentory.
1915
 
        entry = self._get_entry(path=path)
1916
 
        if entry == (None, None):
1917
 
            return None
1918
 
        return entry[0][2]
 
2107
        if isinstance(path, list):
 
2108
            if path == []:
 
2109
                path = [""]
 
2110
            path = osutils.pathjoin(*path)
 
2111
        with self.lock_read():
 
2112
            entry = self._get_entry(path=path)
 
2113
            if entry == (None, None):
 
2114
                nested_tree, subpath = self.get_containing_nested_tree(path)
 
2115
                if nested_tree is not None:
 
2116
                    return nested_tree.path2id(subpath)
 
2117
                return None
 
2118
            return entry[0][2]
1919
2119
 
1920
2120
    def unlock(self):
1921
2121
        """Unlock, freeing any cache memory used during the lock."""
1922
2122
        # outside of a lock, the inventory is suspect: release it.
1923
 
        self._locked -=1
 
2123
        self._locked -= 1
1924
2124
        if not self._locked:
1925
2125
            self._inventory = None
1926
2126
            self._locked = 0
1929
2129
                self._dirstate_locked = False
1930
2130
            self._repository.unlock()
1931
2131
 
1932
 
    @needs_read_lock
1933
2132
    def supports_tree_reference(self):
1934
 
        return self._repo_supports_tree_reference
 
2133
        with self.lock_read():
 
2134
            return self._repo_supports_tree_reference
1935
2135
 
1936
2136
    def walkdirs(self, prefix=""):
1937
2137
        # TODO: jam 20070215 This is the lazy way by using the RevisionTree
1940
2140
        # So for now, we just build up the parent inventory, and extract
1941
2141
        # it the same way RevisionTree does.
1942
2142
        _directory = 'directory'
1943
 
        inv = self._get_inventory()
 
2143
        inv = self._get_root_inventory()
1944
2144
        top_id = inv.path2id(prefix)
1945
2145
        if top_id is None:
1946
2146
            pending = []
1955
2155
            else:
1956
2156
                relroot = ""
1957
2157
            # FIXME: stash the node in pending
1958
 
            entry = inv[file_id]
 
2158
            entry = inv.get_entry(file_id)
1959
2159
            for name, child in entry.sorted_children():
1960
2160
                toppath = relroot + name
1961
2161
                dirblock.append((toppath, name, child.kind, None,
1962
 
                    child.file_id, child.kind
1963
 
                    ))
 
2162
                                 child.file_id, child.kind
 
2163
                                 ))
1964
2164
            yield (relpath, entry.file_id), dirblock
1965
2165
            # push the user specified dirs from dirblock
1966
2166
            for dir in reversed(dirblock):
1981
2181
    def __init__(self, source, target):
1982
2182
        super(InterDirStateTree, self).__init__(source, target)
1983
2183
        if not InterDirStateTree.is_compatible(source, target):
1984
 
            raise Exception, "invalid source %r and target %r" % (source, target)
 
2184
            raise Exception("invalid source %r and target %r" %
 
2185
                            (source, target))
1985
2186
 
1986
2187
    @staticmethod
1987
2188
    def make_source_parent_tree(source, target):
1988
2189
        """Change the source tree into a parent of the target."""
1989
2190
        revid = source.commit('record tree')
1990
 
        target.branch.repository.fetch(source.branch.repository, revid)
 
2191
        target.branch.fetch(source.branch, revid)
1991
2192
        target.set_parent_ids([revid])
1992
2193
        return target.basis_tree(), target
1993
2194
 
2000
2201
    @classmethod
2001
2202
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source,
2002
2203
                                                  target):
2003
 
        from bzrlib.tests.test__dirstate_helpers import \
 
2204
        from ..tests.test__dirstate_helpers import \
2004
2205
            compiled_dirstate_helpers_feature
2005
2206
        test_case.requireFeature(compiled_dirstate_helpers_feature)
2006
 
        from bzrlib._dirstate_helpers_pyx import ProcessEntryC
 
2207
        from ._dirstate_helpers_pyx import ProcessEntryC
2007
2208
        result = klass.make_source_parent_tree(source, target)
2008
2209
        result[1]._iter_changes = ProcessEntryC
2009
2210
        return result
2018
2219
        raise NotImplementedError
2019
2220
 
2020
2221
    def iter_changes(self, include_unchanged=False,
2021
 
                      specific_files=None, pb=None, extra_trees=[],
2022
 
                      require_versioned=True, want_unversioned=False):
 
2222
                     specific_files=None, pb=None, extra_trees=[],
 
2223
                     require_versioned=True, want_unversioned=False):
2023
2224
        """Return the changes from source to target.
2024
2225
 
2025
2226
        :return: An iterator that yields tuples. See InterTree.iter_changes
2060
2261
            if not (self.source._revision_id in parent_ids):
2061
2262
                raise AssertionError(
2062
2263
                    "Failure: source._revision_id: %s not in target.parent_ids(%s)" % (
2063
 
                    self.source._revision_id, parent_ids))
 
2264
                        self.source._revision_id, parent_ids))
2064
2265
            source_index = 1 + parent_ids.index(self.source._revision_id)
2065
2266
            indices = (source_index, target_index)
2066
 
        # -- make all specific_files utf8 --
2067
 
        if specific_files:
2068
 
            specific_files_utf8 = set()
2069
 
            for path in specific_files:
2070
 
                # Note, if there are many specific files, using cache_utf8
2071
 
                # would be good here.
2072
 
                specific_files_utf8.add(path.encode('utf8'))
2073
 
            specific_files = specific_files_utf8
2074
 
        else:
2075
 
            specific_files = set([''])
2076
 
        # -- specific_files is now a utf8 path set --
 
2267
 
 
2268
        if specific_files is None:
 
2269
            specific_files = {''}
2077
2270
 
2078
2271
        # -- get the state object and prepare it.
2079
2272
        state = self.target.current_dirstate()
2082
2275
            # -- check all supplied paths are versioned in a search tree. --
2083
2276
            not_versioned = []
2084
2277
            for path in specific_files:
2085
 
                path_entries = state._entries_for_path(path)
 
2278
                path_entries = state._entries_for_path(path.encode('utf-8'))
2086
2279
                if not path_entries:
2087
2280
                    # this specified path is not present at all: error
2088
2281
                    not_versioned.append(path)
2092
2285
                for entry in path_entries:
2093
2286
                    # for each tree.
2094
2287
                    for index in indices:
2095
 
                        if entry[1][index][0] != 'a': # absent
 
2288
                        if entry[1][index][0] != b'a':  # absent
2096
2289
                            found_versioned = True
2097
2290
                            # all good: found a versioned cell
2098
2291
                            break
2102
2295
                    not_versioned.append(path)
2103
2296
            if len(not_versioned) > 0:
2104
2297
                raise errors.PathsNotVersionedError(not_versioned)
2105
 
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
2106
 
        search_specific_files = osutils.minimum_path_selection(specific_files)
2107
 
 
2108
 
        use_filesystem_for_exec = (sys.platform != 'win32')
2109
 
        iter_changes = self.target._iter_changes(include_unchanged,
2110
 
            use_filesystem_for_exec, search_specific_files, state,
2111
 
            source_index, target_index, want_unversioned, self.target)
 
2298
 
 
2299
        # remove redundancy in supplied specific_files to prevent over-scanning
 
2300
        # make all specific_files utf8
 
2301
        search_specific_files_utf8 = set()
 
2302
        for path in osutils.minimum_path_selection(specific_files):
 
2303
            # Note, if there are many specific files, using cache_utf8
 
2304
            # would be good here.
 
2305
            search_specific_files_utf8.add(path.encode('utf8'))
 
2306
 
 
2307
        iter_changes = self.target._iter_changes(
 
2308
            include_unchanged, self.target._supports_executable(),
 
2309
            search_specific_files_utf8, state, source_index, target_index,
 
2310
            want_unversioned, self.target)
2112
2311
        return iter_changes.iter_changes()
2113
2312
 
2114
2313
    @staticmethod
2118
2317
            return False
2119
2318
        # the source must be a revtree or dirstate rev tree.
2120
2319
        if not isinstance(source,
2121
 
            (revisiontree.RevisionTree, DirStateRevisionTree)):
 
2320
                          (revisiontree.RevisionTree, DirStateRevisionTree)):
2122
2321
            return False
2123
2322
        # the source revid must be in the target dirstate
2124
2323
        if not (source._revision_id == _mod_revision.NULL_REVISION or
2125
 
            source._revision_id in target.get_parent_ids()):
 
2324
                source._revision_id in target.get_parent_ids()):
2126
2325
            # TODO: what about ghosts? it may well need to
2127
2326
            # check for them explicitly.
2128
2327
            return False
2129
2328
        return True
2130
2329
 
 
2330
 
2131
2331
InterTree.register_optimiser(InterDirStateTree)
2132
2332
 
2133
2333
 
2152
2352
 
2153
2353
    def create_dirstate_data(self, tree):
2154
2354
        """Create the dirstate based data for tree."""
2155
 
        local_path = tree.bzrdir.get_workingtree_transport(None
2156
 
            ).local_abspath('dirstate')
 
2355
        local_path = tree.controldir.get_workingtree_transport(
 
2356
            None).local_abspath('dirstate')
2157
2357
        state = dirstate.DirState.from_tree(tree, local_path)
2158
2358
        state.save()
2159
2359
        state.unlock()
2160
2360
 
2161
2361
    def remove_xml_files(self, tree):
2162
2362
        """Remove the oldformat 3 data."""
2163
 
        transport = tree.bzrdir.get_workingtree_transport(None)
 
2363
        transport = tree.controldir.get_workingtree_transport(None)
2164
2364
        for path in ['basis-inventory-cache', 'inventory', 'last-revision',
2165
 
            'pending-merges', 'stat-cache']:
 
2365
                     'pending-merges', 'stat-cache']:
2166
2366
            try:
2167
2367
                transport.delete(path)
2168
2368
            except errors.NoSuchFile:
2172
2372
    def update_format(self, tree):
2173
2373
        """Change the format marker."""
2174
2374
        tree._transport.put_bytes('format',
2175
 
            self.target_format.get_format_string(),
2176
 
            mode=tree.bzrdir._get_file_mode())
 
2375
                                  self.target_format.as_string(),
 
2376
                                  mode=tree.controldir._get_file_mode())
2177
2377
 
2178
2378
 
2179
2379
class Converter4to5(object):
2195
2395
    def update_format(self, tree):
2196
2396
        """Change the format marker."""
2197
2397
        tree._transport.put_bytes('format',
2198
 
            self.target_format.get_format_string(),
2199
 
            mode=tree.bzrdir._get_file_mode())
 
2398
                                  self.target_format.as_string(),
 
2399
                                  mode=tree.controldir._get_file_mode())
2200
2400
 
2201
2401
 
2202
2402
class Converter4or5to6(object):
2218
2418
 
2219
2419
    def init_custom_control_files(self, tree):
2220
2420
        """Initialize custom control files."""
2221
 
        tree._transport.put_bytes('views', '',
2222
 
            mode=tree.bzrdir._get_file_mode())
 
2421
        tree._transport.put_bytes('views', b'',
 
2422
                                  mode=tree.controldir._get_file_mode())
2223
2423
 
2224
2424
    def update_format(self, tree):
2225
2425
        """Change the format marker."""
2226
2426
        tree._transport.put_bytes('format',
2227
 
            self.target_format.get_format_string(),
2228
 
            mode=tree.bzrdir._get_file_mode())
 
2427
                                  self.target_format.as_string(),
 
2428
                                  mode=tree.controldir._get_file_mode())