/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 brzlib/workingtree.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 12:41:27 UTC
  • mto: This revision was merged to the branch mainline in revision 6623.
  • Revision ID: jelmer@jelmer.uk-20170521124127-iv8etg0vwymyai6y
s/bzr/brz/ in apport config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
brzlib/workingtree.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
29
29
WorkingTree.open(dir).
30
30
"""
31
31
 
 
32
from __future__ import absolute_import
32
33
 
33
34
from cStringIO import StringIO
34
35
import os
35
36
import sys
36
37
 
37
 
from bzrlib.lazy_import import lazy_import
 
38
from brzlib.lazy_import import lazy_import
38
39
lazy_import(globals(), """
39
40
from bisect import bisect_left
40
41
import collections
44
45
import stat
45
46
import re
46
47
 
47
 
import bzrlib
48
 
from bzrlib import (
 
48
from brzlib import (
49
49
    branch,
50
 
    bzrdir,
51
50
    conflicts as _mod_conflicts,
 
51
    controldir,
52
52
    errors,
 
53
    filters as _mod_filters,
53
54
    generate_ids,
54
55
    globbing,
55
56
    graph as _mod_graph,
56
 
    hashcache,
57
57
    ignores,
58
58
    inventory,
59
59
    merge,
60
60
    revision as _mod_revision,
61
61
    revisiontree,
62
 
    trace,
 
62
    rio as _mod_rio,
 
63
    shelf,
63
64
    transform,
 
65
    transport,
64
66
    ui,
65
67
    views,
66
68
    xml5,
67
69
    xml7,
68
70
    )
69
 
import bzrlib.branch
70
 
from bzrlib.transport import get_transport
71
 
from bzrlib.workingtree_4 import (
72
 
    WorkingTreeFormat4,
73
 
    WorkingTreeFormat5,
74
 
    WorkingTreeFormat6,
75
 
    )
76
71
""")
77
72
 
78
 
from bzrlib import symbol_versioning
79
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
80
 
from bzrlib.lockable_files import LockableFiles
81
 
from bzrlib.lockdir import LockDir
82
 
import bzrlib.mutabletree
83
 
from bzrlib.mutabletree import needs_tree_write_lock
84
 
from bzrlib import osutils
85
 
from bzrlib.osutils import (
 
73
# Explicitly import brzlib.bzrdir so that the BzrProber
 
74
# is guaranteed to be registered.
 
75
from brzlib import (
 
76
    bzrdir,
 
77
    symbol_versioning,
 
78
    )
 
79
 
 
80
from brzlib.decorators import needs_read_lock, needs_write_lock
 
81
from brzlib.i18n import gettext
 
82
from brzlib.lock import LogicalLockResult
 
83
import brzlib.mutabletree
 
84
from brzlib.mutabletree import needs_tree_write_lock
 
85
from brzlib import osutils
 
86
from brzlib.osutils import (
86
87
    file_kind,
87
88
    isdir,
88
89
    normpath,
90
91
    realpath,
91
92
    safe_unicode,
92
93
    splitpath,
93
 
    supports_executable,
94
94
    )
95
 
from bzrlib.filters import filtered_input_file
96
 
from bzrlib.trace import mutter, note
97
 
from bzrlib.transport.local import LocalTransport
98
 
from bzrlib.revision import CURRENT_REVISION
99
 
from bzrlib.rio import RioReader, rio_file, Stanza
100
 
from bzrlib.symbol_versioning import (
 
95
from brzlib.trace import mutter, note
 
96
from brzlib.revision import CURRENT_REVISION
 
97
from brzlib.symbol_versioning import (
101
98
    deprecated_passed,
102
99
    DEPRECATED_PARAMETER,
103
100
    )
167
164
        return ''
168
165
 
169
166
 
170
 
class WorkingTree(bzrlib.mutabletree.MutableTree,
171
 
    bzrdir.ControlComponent):
 
167
class WorkingTree(brzlib.mutabletree.MutableTree,
 
168
    controldir.ControlComponent):
172
169
    """Working copy tree.
173
170
 
174
 
    The inventory is held in the `Branch` working-inventory, and the
175
 
    files are in a directory on disk.
176
 
 
177
 
    It is possible for a `WorkingTree` to have a filename which is
178
 
    not listed in the Inventory and vice versa.
 
171
    :ivar basedir: The root of the tree on disk. This is a unicode path object
 
172
        (as opposed to a URL).
179
173
    """
180
174
 
181
175
    # override this to set the strategy for storing views
184
178
 
185
179
    def __init__(self, basedir='.',
186
180
                 branch=DEPRECATED_PARAMETER,
187
 
                 _inventory=None,
188
 
                 _control_files=None,
189
181
                 _internal=False,
 
182
                 _transport=None,
190
183
                 _format=None,
191
184
                 _bzrdir=None):
192
185
        """Construct a WorkingTree instance. This is not a public API.
205
198
        else:
206
199
            self._branch = self.bzrdir.open_branch()
207
200
        self.basedir = realpath(basedir)
208
 
        # if branch is at our basedir and is a format 6 or less
209
 
        if isinstance(self._format, WorkingTreeFormat2):
210
 
            # share control object
211
 
            self._control_files = self.branch.control_files
212
 
        else:
213
 
            # assume all other formats have their own control files.
214
 
            self._control_files = _control_files
215
 
        self._transport = self._control_files._transport
216
 
        # update the whole cache up front and write to disk if anything changed;
217
 
        # in the future we might want to do this more selectively
218
 
        # two possible ways offer themselves : in self._unlock, write the cache
219
 
        # if needed, or, when the cache sees a change, append it to the hash
220
 
        # cache file, and have the parser take the most recent entry for a
221
 
        # given path only.
222
 
        wt_trans = self.bzrdir.get_workingtree_transport(None)
223
 
        cache_filename = wt_trans.local_abspath('stat-cache')
224
 
        self._hashcache = hashcache.HashCache(basedir, cache_filename,
225
 
            self.bzrdir._get_file_mode(),
226
 
            self._content_filter_stack_provider())
227
 
        hc = self._hashcache
228
 
        hc.read()
229
 
        # is this scan needed ? it makes things kinda slow.
230
 
        #hc.scan()
231
 
 
232
 
        if hc.needs_write:
233
 
            mutter("write hc")
234
 
            hc.write()
235
 
 
236
 
        if _inventory is None:
237
 
            # This will be acquired on lock_read() or lock_write()
238
 
            self._inventory_is_modified = False
239
 
            self._inventory = None
240
 
        else:
241
 
            # the caller of __init__ has provided an inventory,
242
 
            # we assume they know what they are doing - as its only
243
 
            # the Format factory and creation methods that are
244
 
            # permitted to do this.
245
 
            self._set_inventory(_inventory, dirty=False)
246
 
        self._detect_case_handling()
 
201
        self._transport = _transport
247
202
        self._rules_searcher = None
248
203
        self.views = self._make_views()
249
204
 
255
210
    def control_transport(self):
256
211
        return self._transport
257
212
 
258
 
    def _detect_case_handling(self):
259
 
        wt_trans = self.bzrdir.get_workingtree_transport(None)
260
 
        try:
261
 
            wt_trans.stat("FoRMaT")
262
 
        except errors.NoSuchFile:
263
 
            self.case_sensitive = True
264
 
        else:
265
 
            self.case_sensitive = False
266
 
 
267
 
        self._setup_directory_is_tree_reference()
 
213
    def is_control_filename(self, filename):
 
214
        """True if filename is the name of a control file in this tree.
 
215
 
 
216
        :param filename: A filename within the tree. This is a relative path
 
217
            from the root of this tree.
 
218
 
 
219
        This is true IF and ONLY IF the filename is part of the meta data
 
220
        that bzr controls in this tree. I.E. a random .bzr directory placed
 
221
        on disk will not be a control file for this tree.
 
222
        """
 
223
        return self.bzrdir.is_control_filename(filename)
268
224
 
269
225
    branch = property(
270
226
        fget=lambda self: self._branch,
274
230
            the working tree has been constructed from.
275
231
            """)
276
232
 
 
233
    def has_versioned_directories(self):
 
234
        """See `Tree.has_versioned_directories`."""
 
235
        return self._format.supports_versioned_directories
 
236
 
 
237
    def _supports_executable(self):
 
238
        if sys.platform == 'win32':
 
239
            return False
 
240
        # FIXME: Ideally this should check the file system
 
241
        return True
 
242
 
277
243
    def break_lock(self):
278
244
        """Break a lock if one is present from another instance.
279
245
 
282
248
 
283
249
        This will probe the repository for its lock as well.
284
250
        """
285
 
        self._control_files.break_lock()
286
 
        self.branch.break_lock()
287
 
 
288
 
    def _get_check_refs(self):
289
 
        """Return the references needed to perform a check of this tree.
290
 
        
291
 
        The default implementation returns no refs, and is only suitable for
292
 
        trees that have no local caching and can commit on ghosts at any time.
293
 
 
294
 
        :seealso: bzrlib.check for details about check_refs.
295
 
        """
296
 
        return []
 
251
        raise NotImplementedError(self.break_lock)
297
252
 
298
253
    def requires_rich_root(self):
299
254
        return self._format.requires_rich_root
307
262
    def supports_views(self):
308
263
        return self.views.supports_views()
309
264
 
310
 
    def _set_inventory(self, inv, dirty):
311
 
        """Set the internal cached inventory.
 
265
    def get_config_stack(self):
 
266
        """Retrieve the config stack for this tree.
312
267
 
313
 
        :param inv: The inventory to set.
314
 
        :param dirty: A boolean indicating whether the inventory is the same
315
 
            logical inventory as whats on disk. If True the inventory is not
316
 
            the same and should be written to disk or data will be lost, if
317
 
            False then the inventory is the same as that on disk and any
318
 
            serialisation would be unneeded overhead.
 
268
        :return: A ``brzlib.config.Stack``
319
269
        """
320
 
        self._inventory = inv
321
 
        self._inventory_is_modified = dirty
 
270
        # For the moment, just provide the branch config stack.
 
271
        return self.branch.get_config_stack()
322
272
 
323
273
    @staticmethod
324
274
    def open(path=None, _unsupported=False):
327
277
        """
328
278
        if path is None:
329
279
            path = osutils.getcwd()
330
 
        control = bzrdir.BzrDir.open(path, _unsupported)
331
 
        return control.open_workingtree(_unsupported)
 
280
        control = controldir.ControlDir.open(path, _unsupported=_unsupported)
 
281
        return control.open_workingtree(unsupported=_unsupported)
332
282
 
333
283
    @staticmethod
334
284
    def open_containing(path=None):
345
295
        """
346
296
        if path is None:
347
297
            path = osutils.getcwd()
348
 
        control, relpath = bzrdir.BzrDir.open_containing(path)
349
 
 
 
298
        control, relpath = controldir.ControlDir.open_containing(path)
350
299
        return control.open_workingtree(), relpath
351
300
 
352
301
    @staticmethod
 
302
    def open_containing_paths(file_list, default_directory=None,
 
303
                              canonicalize=True, apply_view=True):
 
304
        """Open the WorkingTree that contains a set of paths.
 
305
 
 
306
        Fail if the paths given are not all in a single tree.
 
307
 
 
308
        This is used for the many command-line interfaces that take a list of
 
309
        any number of files and that require they all be in the same tree.
 
310
        """
 
311
        if default_directory is None:
 
312
            default_directory = u'.'
 
313
        # recommended replacement for builtins.internal_tree_files
 
314
        if file_list is None or len(file_list) == 0:
 
315
            tree = WorkingTree.open_containing(default_directory)[0]
 
316
            # XXX: doesn't really belong here, and seems to have the strange
 
317
            # side effect of making it return a bunch of files, not the whole
 
318
            # tree -- mbp 20100716
 
319
            if tree.supports_views() and apply_view:
 
320
                view_files = tree.views.lookup_view()
 
321
                if view_files:
 
322
                    file_list = view_files
 
323
                    view_str = views.view_display_str(view_files)
 
324
                    note(gettext("Ignoring files outside view. View is %s") % view_str)
 
325
            return tree, file_list
 
326
        if default_directory == u'.':
 
327
            seed = file_list[0]
 
328
        else:
 
329
            seed = default_directory
 
330
            file_list = [osutils.pathjoin(default_directory, f)
 
331
                         for f in file_list]
 
332
        tree = WorkingTree.open_containing(seed)[0]
 
333
        return tree, tree.safe_relpath_files(file_list, canonicalize,
 
334
                                             apply_view=apply_view)
 
335
 
 
336
    def safe_relpath_files(self, file_list, canonicalize=True, apply_view=True):
 
337
        """Convert file_list into a list of relpaths in tree.
 
338
 
 
339
        :param self: A tree to operate on.
 
340
        :param file_list: A list of user provided paths or None.
 
341
        :param apply_view: if True and a view is set, apply it or check that
 
342
            specified files are within it
 
343
        :return: A list of relative paths.
 
344
        :raises errors.PathNotChild: When a provided path is in a different self
 
345
            than self.
 
346
        """
 
347
        if file_list is None:
 
348
            return None
 
349
        if self.supports_views() and apply_view:
 
350
            view_files = self.views.lookup_view()
 
351
        else:
 
352
            view_files = []
 
353
        new_list = []
 
354
        # self.relpath exists as a "thunk" to osutils, but canonical_relpath
 
355
        # doesn't - fix that up here before we enter the loop.
 
356
        if canonicalize:
 
357
            fixer = lambda p: osutils.canonical_relpath(self.basedir, p)
 
358
        else:
 
359
            fixer = self.relpath
 
360
        for filename in file_list:
 
361
            relpath = fixer(osutils.dereference_path(filename))
 
362
            if view_files and not osutils.is_inside_any(view_files, relpath):
 
363
                raise errors.FileOutsideView(filename, view_files)
 
364
            new_list.append(relpath)
 
365
        return new_list
 
366
 
 
367
    @staticmethod
353
368
    def open_downlevel(path=None):
354
369
        """Open an unsupported working tree.
355
370
 
368
383
                return True, None
369
384
            else:
370
385
                return True, tree
371
 
        transport = get_transport(location)
372
 
        iterator = bzrdir.BzrDir.find_bzrdirs(transport, evaluate=evaluate,
 
386
        t = transport.get_transport(location)
 
387
        iterator = controldir.ControlDir.find_bzrdirs(t, evaluate=evaluate,
373
388
                                              list_current=list_current)
374
 
        return [t for t in iterator if t is not None]
375
 
 
376
 
    # should be deprecated - this is slow and in any case treating them as a
377
 
    # container is (we now know) bad style -- mbp 20070302
378
 
    ## @deprecated_method(zero_fifteen)
379
 
    def __iter__(self):
380
 
        """Iterate through file_ids for this tree.
381
 
 
382
 
        file_ids are in a WorkingTree if they are in the working inventory
383
 
        and the working file exists.
384
 
        """
385
 
        inv = self._inventory
386
 
        for path, ie in inv.iter_entries():
387
 
            if osutils.lexists(self.abspath(path)):
388
 
                yield ie.file_id
389
 
 
390
 
    def all_file_ids(self):
391
 
        """See Tree.iter_all_file_ids"""
392
 
        return set(self.inventory)
 
389
        return [tr for tr in iterator if tr is not None]
393
390
 
394
391
    def __repr__(self):
395
392
        return "<%s of %s>" % (self.__class__.__name__,
450
447
        return self.get_file_with_stat(file_id, path, filtered=filtered)[0]
451
448
 
452
449
    def get_file_with_stat(self, file_id, path=None, filtered=True,
453
 
        _fstat=os.fstat):
 
450
                           _fstat=osutils.fstat):
454
451
        """See Tree.get_file_with_stat."""
455
452
        if path is None:
456
453
            path = self.id2path(file_id)
458
455
        stat_value = _fstat(file_obj.fileno())
459
456
        if filtered and self.supports_content_filtering():
460
457
            filters = self._content_filter_stack(path)
461
 
            file_obj = filtered_input_file(file_obj, filters)
 
458
            file_obj = _mod_filters.filtered_input_file(file_obj, filters)
462
459
        return (file_obj, stat_value)
463
460
 
464
461
    def get_file_text(self, file_id, path=None, filtered=True):
465
 
        return self.get_file(file_id, path=path, filtered=filtered).read()
 
462
        my_file = self.get_file(file_id, path=path, filtered=filtered)
 
463
        try:
 
464
            return my_file.read()
 
465
        finally:
 
466
            my_file.close()
466
467
 
467
468
    def get_file_byname(self, filename, filtered=True):
468
469
        path = self.abspath(filename)
469
470
        f = file(path, 'rb')
470
471
        if filtered and self.supports_content_filtering():
471
472
            filters = self._content_filter_stack(filename)
472
 
            return filtered_input_file(f, filters)
 
473
            return _mod_filters.filtered_input_file(f, filters)
473
474
        else:
474
475
            return f
475
476
 
481
482
        finally:
482
483
            file.close()
483
484
 
484
 
    @needs_read_lock
485
 
    def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
486
 
        """See Tree.annotate_iter
487
 
 
488
 
        This implementation will use the basis tree implementation if possible.
489
 
        Lines not in the basis are attributed to CURRENT_REVISION
490
 
 
491
 
        If there are pending merges, lines added by those merges will be
492
 
        incorrectly attributed to CURRENT_REVISION (but after committing, the
493
 
        attribution will be correct).
494
 
        """
495
 
        maybe_file_parent_keys = []
496
 
        for parent_id in self.get_parent_ids():
497
 
            try:
498
 
                parent_tree = self.revision_tree(parent_id)
499
 
            except errors.NoSuchRevisionInTree:
500
 
                parent_tree = self.branch.repository.revision_tree(parent_id)
501
 
            parent_tree.lock_read()
502
 
            try:
503
 
                if file_id not in parent_tree:
504
 
                    continue
505
 
                ie = parent_tree.inventory[file_id]
506
 
                if ie.kind != 'file':
507
 
                    # Note: this is slightly unnecessary, because symlinks and
508
 
                    # directories have a "text" which is the empty text, and we
509
 
                    # know that won't mess up annotations. But it seems cleaner
510
 
                    continue
511
 
                parent_text_key = (file_id, ie.revision)
512
 
                if parent_text_key not in maybe_file_parent_keys:
513
 
                    maybe_file_parent_keys.append(parent_text_key)
514
 
            finally:
515
 
                parent_tree.unlock()
516
 
        graph = _mod_graph.Graph(self.branch.repository.texts)
517
 
        heads = graph.heads(maybe_file_parent_keys)
518
 
        file_parent_keys = []
519
 
        for key in maybe_file_parent_keys:
520
 
            if key in heads:
521
 
                file_parent_keys.append(key)
522
 
 
523
 
        # Now we have the parents of this content
524
 
        annotator = self.branch.repository.texts.get_annotator()
525
 
        text = self.get_file(file_id).read()
526
 
        this_key =(file_id, default_revision)
527
 
        annotator.add_special_text(this_key, file_parent_keys, text)
528
 
        annotations = [(key[-1], line)
529
 
                       for key, line in annotator.annotate_flat(this_key)]
530
 
        return annotations
531
 
 
532
 
    def _get_ancestors(self, default_revision):
533
 
        ancestors = set([default_revision])
534
 
        for parent_id in self.get_parent_ids():
535
 
            ancestors.update(self.branch.repository.get_ancestry(
536
 
                             parent_id, topo_sorted=False))
537
 
        return ancestors
538
 
 
539
485
    def get_parent_ids(self):
540
486
        """See Tree.get_parent_ids.
541
487
 
557
503
                parents.append(revision_id)
558
504
        return parents
559
505
 
560
 
    @needs_read_lock
561
506
    def get_root_id(self):
562
507
        """Return the id of this trees root"""
563
 
        return self._inventory.root.file_id
564
 
 
565
 
    def _get_store_filename(self, file_id):
566
 
        ## XXX: badly named; this is not in the store at all
567
 
        return self.abspath(self.id2path(file_id))
 
508
        raise NotImplementedError(self.get_root_id)
568
509
 
569
510
    @needs_read_lock
570
 
    def clone(self, to_bzrdir, revision_id=None):
 
511
    def clone(self, to_controldir, revision_id=None):
571
512
        """Duplicate this working tree into to_bzr, including all state.
572
513
 
573
514
        Specifically modified files are kept as modified, but
574
515
        ignored and unknown files are discarded.
575
516
 
576
 
        If you want to make a new line of development, see bzrdir.sprout()
 
517
        If you want to make a new line of development, see ControlDir.sprout()
577
518
 
578
519
        revision
579
520
            If not None, the cloned tree will have its last revision set to
581
522
            and this one merged in.
582
523
        """
583
524
        # assumes the target bzr dir format is compatible.
584
 
        result = to_bzrdir.create_workingtree()
 
525
        result = to_controldir.create_workingtree()
585
526
        self.copy_content_into(result, revision_id)
586
527
        return result
587
528
 
594
535
        else:
595
536
            # TODO now merge from tree.last_revision to revision (to preserve
596
537
            # user local changes)
597
 
            merge.transform_tree(tree, self)
598
 
            tree.set_parent_ids([revision_id])
 
538
            try:
 
539
                other_tree = self.revision_tree(revision_id)
 
540
            except errors.NoSuchRevision:
 
541
                other_tree = self.branch.repository.revision_tree(revision_id)
 
542
 
 
543
            merge.transform_tree(tree, other_tree)
 
544
            if revision_id == _mod_revision.NULL_REVISION:
 
545
                new_parents = []
 
546
            else:
 
547
                new_parents = [revision_id]
 
548
            tree.set_parent_ids(new_parents)
599
549
 
600
550
    def id2abspath(self, file_id):
601
551
        return self.abspath(self.id2path(file_id))
602
552
 
603
 
    def has_id(self, file_id):
604
 
        # files that have been deleted are excluded
605
 
        inv = self.inventory
606
 
        if not inv.has_id(file_id):
607
 
            return False
608
 
        path = inv.id2path(file_id)
609
 
        return osutils.lexists(self.abspath(path))
610
 
 
611
 
    def has_or_had_id(self, file_id):
612
 
        if file_id == self.inventory.root.file_id:
613
 
            return True
614
 
        return self.inventory.has_id(file_id)
615
 
 
616
 
    __contains__ = has_id
 
553
    def _check_for_tree_references(self, iterator):
 
554
        """See if directories have become tree-references."""
 
555
        blocked_parent_ids = set()
 
556
        for path, ie in iterator:
 
557
            if ie.parent_id in blocked_parent_ids:
 
558
                # This entry was pruned because one of its parents became a
 
559
                # TreeReference. If this is a directory, mark it as blocked.
 
560
                if ie.kind == 'directory':
 
561
                    blocked_parent_ids.add(ie.file_id)
 
562
                continue
 
563
            if ie.kind == 'directory' and self._directory_is_tree_reference(path):
 
564
                # This InventoryDirectory needs to be a TreeReference
 
565
                ie = inventory.TreeReference(ie.file_id, ie.name, ie.parent_id)
 
566
                blocked_parent_ids.add(ie.file_id)
 
567
            yield path, ie
 
568
 
 
569
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
 
570
        """See Tree.iter_entries_by_dir()"""
 
571
        # The only trick here is that if we supports_tree_reference then we
 
572
        # need to detect if a directory becomes a tree-reference.
 
573
        iterator = super(WorkingTree, self).iter_entries_by_dir(
 
574
                specific_file_ids=specific_file_ids,
 
575
                yield_parents=yield_parents)
 
576
        if not self.supports_tree_reference():
 
577
            return iterator
 
578
        else:
 
579
            return self._check_for_tree_references(iterator)
617
580
 
618
581
    def get_file_size(self, file_id):
619
582
        """See Tree.get_file_size"""
627
590
            else:
628
591
                return None
629
592
 
630
 
    @needs_read_lock
631
 
    def get_file_sha1(self, file_id, path=None, stat_value=None):
632
 
        if not path:
633
 
            path = self._inventory.id2path(file_id)
634
 
        return self._hashcache.get_sha1(path, stat_value)
635
 
 
636
 
    def get_file_mtime(self, file_id, path=None):
637
 
        if not path:
638
 
            path = self.inventory.id2path(file_id)
639
 
        return os.lstat(self.abspath(path)).st_mtime
640
 
 
641
 
    def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
642
 
        file_id = self.path2id(path)
643
 
        if file_id is None:
644
 
            # For unversioned files on win32, we just assume they are not
645
 
            # executable
646
 
            return False
647
 
        return self._inventory[file_id].executable
648
 
 
649
 
    def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
650
 
        mode = stat_result.st_mode
651
 
        return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
652
 
 
653
 
    if not supports_executable():
654
 
        def is_executable(self, file_id, path=None):
655
 
            return self._inventory[file_id].executable
656
 
 
657
 
        _is_executable_from_path_and_stat = \
658
 
            _is_executable_from_path_and_stat_from_basis
659
 
    else:
660
 
        def is_executable(self, file_id, path=None):
661
 
            if not path:
662
 
                path = self.id2path(file_id)
663
 
            mode = os.lstat(self.abspath(path)).st_mode
664
 
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
665
 
 
666
 
        _is_executable_from_path_and_stat = \
667
 
            _is_executable_from_path_and_stat_from_stat
668
 
 
669
 
    @needs_tree_write_lock
670
 
    def _add(self, files, ids, kinds):
671
 
        """See MutableTree._add."""
672
 
        # TODO: Re-adding a file that is removed in the working copy
673
 
        # should probably put it back with the previous ID.
674
 
        # the read and write working inventory should not occur in this
675
 
        # function - they should be part of lock_write and unlock.
676
 
        inv = self.inventory
677
 
        for f, file_id, kind in zip(files, ids, kinds):
678
 
            if file_id is None:
679
 
                inv.add_path(f, kind=kind)
680
 
            else:
681
 
                inv.add_path(f, kind=kind, file_id=file_id)
682
 
            self._inventory_is_modified = True
683
 
 
684
593
    @needs_tree_write_lock
685
594
    def _gather_kinds(self, files, kinds):
686
595
        """See MutableTree._gather_kinds."""
701
610
        and setting the list to its value plus revision_id.
702
611
 
703
612
        :param revision_id: The revision id to add to the parent list. It may
704
 
        be a ghost revision as long as its not the first parent to be added,
705
 
        or the allow_leftmost_as_ghost parameter is set True.
 
613
            be a ghost revision as long as its not the first parent to be
 
614
            added, or the allow_leftmost_as_ghost parameter is set True.
706
615
        :param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
707
616
        """
708
617
        parents = self.get_parent_ids() + [revision_id]
811
720
            if revision_id in heads and revision_id not in new_revision_ids:
812
721
                new_revision_ids.append(revision_id)
813
722
        if new_revision_ids != revision_ids:
814
 
            trace.mutter('requested to set revision_ids = %s,'
 
723
            mutter('requested to set revision_ids = %s,'
815
724
                         ' but filtered to %s', revision_ids, new_revision_ids)
816
725
        return new_revision_ids
817
726
 
843
752
        self._set_merges_from_parent_ids(revision_ids)
844
753
 
845
754
    @needs_tree_write_lock
846
 
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
847
 
        """See MutableTree.set_parent_trees."""
848
 
        parent_ids = [rev for (rev, tree) in parents_list]
849
 
        for revision_id in parent_ids:
850
 
            _mod_revision.check_not_reserved_id(revision_id)
851
 
 
852
 
        self._check_parents_for_ghosts(parent_ids,
853
 
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
854
 
 
855
 
        parent_ids = self._filter_parent_ids_by_ancestry(parent_ids)
856
 
 
857
 
        if len(parent_ids) == 0:
858
 
            leftmost_parent_id = _mod_revision.NULL_REVISION
859
 
            leftmost_parent_tree = None
860
 
        else:
861
 
            leftmost_parent_id, leftmost_parent_tree = parents_list[0]
862
 
 
863
 
        if self._change_last_revision(leftmost_parent_id):
864
 
            if leftmost_parent_tree is None:
865
 
                # If we don't have a tree, fall back to reading the
866
 
                # parent tree from the repository.
867
 
                self._cache_basis_inventory(leftmost_parent_id)
868
 
            else:
869
 
                inv = leftmost_parent_tree.inventory
870
 
                xml = self._create_basis_xml_from_inventory(
871
 
                                        leftmost_parent_id, inv)
872
 
                self._write_basis_inventory(xml)
873
 
        self._set_merges_from_parent_ids(parent_ids)
874
 
 
875
 
    @needs_tree_write_lock
876
755
    def set_pending_merges(self, rev_list):
877
756
        parents = self.get_parent_ids()
878
757
        leftmost = parents[:1]
881
760
 
882
761
    @needs_tree_write_lock
883
762
    def set_merge_modified(self, modified_hashes):
884
 
        def iter_stanzas():
885
 
            for file_id, hash in modified_hashes.iteritems():
886
 
                yield Stanza(file_id=file_id.decode('utf8'), hash=hash)
887
 
        self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
 
763
        """Set the merge modified hashes."""
 
764
        raise NotImplementedError(self.set_merge_modified)
888
765
 
889
766
    def _sha_from_stat(self, path, stat_result):
890
767
        """Get a sha digest from the tree's stat cache.
896
773
        """
897
774
        return None
898
775
 
899
 
    def _put_rio(self, filename, stanzas, header):
900
 
        self._must_be_locked()
901
 
        my_file = rio_file(stanzas, header)
902
 
        self._transport.put_file(filename, my_file,
903
 
            mode=self.bzrdir._get_file_mode())
904
 
 
905
776
    @needs_write_lock # because merge pulls data into the branch.
906
777
    def merge_from_branch(self, branch, to_revision=None, from_revision=None,
907
778
                          merge_type=None, force=False):
913
784
            of the branch when it is supplied. If None, to_revision defaults to
914
785
            branch.last_revision().
915
786
        """
916
 
        from bzrlib.merge import Merger, Merge3Merger
 
787
        from brzlib.merge import Merger, Merge3Merger
917
788
        merger = Merger(self.branch, this_tree=self)
918
789
        # check that there are no local alterations
919
790
        if not force and self.has_changes():
946
817
        merger.set_pending()
947
818
        return conflicts
948
819
 
949
 
    @needs_read_lock
950
820
    def merge_modified(self):
951
821
        """Return a dictionary of files modified by a merge.
952
822
 
957
827
        This returns a map of file_id->sha1, containing only files which are
958
828
        still in the working inventory and have that text hash.
959
829
        """
960
 
        try:
961
 
            hashfile = self._transport.get('merge-hashes')
962
 
        except errors.NoSuchFile:
963
 
            return {}
964
 
        try:
965
 
            merge_hashes = {}
966
 
            try:
967
 
                if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
968
 
                    raise errors.MergeModifiedFormatError()
969
 
            except StopIteration:
970
 
                raise errors.MergeModifiedFormatError()
971
 
            for s in RioReader(hashfile):
972
 
                # RioReader reads in Unicode, so convert file_ids back to utf8
973
 
                file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
974
 
                if file_id not in self.inventory:
975
 
                    continue
976
 
                text_hash = s.get("hash")
977
 
                if text_hash == self.get_file_sha1(file_id):
978
 
                    merge_hashes[file_id] = text_hash
979
 
            return merge_hashes
980
 
        finally:
981
 
            hashfile.close()
 
830
        raise NotImplementedError(self.merge_modified)
982
831
 
983
832
    @needs_write_lock
984
833
    def mkdir(self, path, file_id=None):
989
838
        self.add(path, file_id, 'directory')
990
839
        return file_id
991
840
 
992
 
    def get_symlink_target(self, file_id):
993
 
        abspath = self.id2abspath(file_id)
 
841
    def get_symlink_target(self, file_id, path=None):
 
842
        if path is not None:
 
843
            abspath = self.abspath(path)
 
844
        else:
 
845
            abspath = self.id2abspath(file_id)
994
846
        target = osutils.readlink(abspath)
995
847
        return target
996
848
 
997
 
    @needs_write_lock
998
849
    def subsume(self, other_tree):
999
 
        def add_children(inventory, entry):
1000
 
            for child_entry in entry.children.values():
1001
 
                inventory._byid[child_entry.file_id] = child_entry
1002
 
                if child_entry.kind == 'directory':
1003
 
                    add_children(inventory, child_entry)
1004
 
        if other_tree.get_root_id() == self.get_root_id():
1005
 
            raise errors.BadSubsumeSource(self, other_tree,
1006
 
                                          'Trees have the same root')
1007
 
        try:
1008
 
            other_tree_path = self.relpath(other_tree.basedir)
1009
 
        except errors.PathNotChild:
1010
 
            raise errors.BadSubsumeSource(self, other_tree,
1011
 
                'Tree is not contained by the other')
1012
 
        new_root_parent = self.path2id(osutils.dirname(other_tree_path))
1013
 
        if new_root_parent is None:
1014
 
            raise errors.BadSubsumeSource(self, other_tree,
1015
 
                'Parent directory is not versioned.')
1016
 
        # We need to ensure that the result of a fetch will have a
1017
 
        # versionedfile for the other_tree root, and only fetching into
1018
 
        # RepositoryKnit2 guarantees that.
1019
 
        if not self.branch.repository.supports_rich_root():
1020
 
            raise errors.SubsumeTargetNeedsUpgrade(other_tree)
1021
 
        other_tree.lock_tree_write()
1022
 
        try:
1023
 
            new_parents = other_tree.get_parent_ids()
1024
 
            other_root = other_tree.inventory.root
1025
 
            other_root.parent_id = new_root_parent
1026
 
            other_root.name = osutils.basename(other_tree_path)
1027
 
            self.inventory.add(other_root)
1028
 
            add_children(self.inventory, other_root)
1029
 
            self._write_inventory(self.inventory)
1030
 
            # normally we don't want to fetch whole repositories, but i think
1031
 
            # here we really do want to consolidate the whole thing.
1032
 
            for parent_id in other_tree.get_parent_ids():
1033
 
                self.branch.fetch(other_tree.branch, parent_id)
1034
 
                self.add_parent_tree_id(parent_id)
1035
 
        finally:
1036
 
            other_tree.unlock()
1037
 
        other_tree.bzrdir.retire_bzrdir()
 
850
        raise NotImplementedError(self.subsume)
1038
851
 
1039
852
    def _setup_directory_is_tree_reference(self):
1040
853
        if self._branch.repository._format.supports_tree_reference:
1062
875
        # checkout in a subdirectory.  This can be avoided by not adding
1063
876
        # it.  mbp 20070306
1064
877
 
1065
 
    @needs_tree_write_lock
1066
878
    def extract(self, file_id, format=None):
1067
879
        """Extract a subtree from this tree.
1068
880
 
1069
881
        A new branch will be created, relative to the path for this tree.
1070
882
        """
1071
 
        self.flush()
1072
 
        def mkdirs(path):
1073
 
            segments = osutils.splitpath(path)
1074
 
            transport = self.branch.bzrdir.root_transport
1075
 
            for name in segments:
1076
 
                transport = transport.clone(name)
1077
 
                transport.ensure_base()
1078
 
            return transport
1079
 
 
1080
 
        sub_path = self.id2path(file_id)
1081
 
        branch_transport = mkdirs(sub_path)
1082
 
        if format is None:
1083
 
            format = self.bzrdir.cloning_metadir()
1084
 
        branch_transport.ensure_base()
1085
 
        branch_bzrdir = format.initialize_on_transport(branch_transport)
1086
 
        try:
1087
 
            repo = branch_bzrdir.find_repository()
1088
 
        except errors.NoRepositoryPresent:
1089
 
            repo = branch_bzrdir.create_repository()
1090
 
        if not repo.supports_rich_root():
1091
 
            raise errors.RootNotRich()
1092
 
        new_branch = branch_bzrdir.create_branch()
1093
 
        new_branch.pull(self.branch)
1094
 
        for parent_id in self.get_parent_ids():
1095
 
            new_branch.fetch(self.branch, parent_id)
1096
 
        tree_transport = self.bzrdir.root_transport.clone(sub_path)
1097
 
        if tree_transport.base != branch_transport.base:
1098
 
            tree_bzrdir = format.initialize_on_transport(tree_transport)
1099
 
            branch.BranchReferenceFormat().initialize(tree_bzrdir,
1100
 
                target_branch=new_branch)
1101
 
        else:
1102
 
            tree_bzrdir = branch_bzrdir
1103
 
        wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
1104
 
        wt.set_parent_ids(self.get_parent_ids())
1105
 
        my_inv = self.inventory
1106
 
        child_inv = inventory.Inventory(root_id=None)
1107
 
        new_root = my_inv[file_id]
1108
 
        my_inv.remove_recursive_id(file_id)
1109
 
        new_root.parent_id = None
1110
 
        child_inv.add(new_root)
1111
 
        self._write_inventory(my_inv)
1112
 
        wt._write_inventory(child_inv)
1113
 
        return wt
1114
 
 
1115
 
    def _serialize(self, inventory, out_file):
1116
 
        xml5.serializer_v5.write_inventory(self._inventory, out_file,
1117
 
            working=True)
1118
 
 
1119
 
    def _deserialize(selt, in_file):
1120
 
        return xml5.serializer_v5.read_inventory(in_file)
 
883
        raise NotImplementedError(self.extract)
1121
884
 
1122
885
    def flush(self):
1123
 
        """Write the in memory inventory to disk."""
1124
 
        # TODO: Maybe this should only write on dirty ?
1125
 
        if self._control_files._lock_mode != 'w':
1126
 
            raise errors.NotWriteLocked(self)
1127
 
        sio = StringIO()
1128
 
        self._serialize(self._inventory, sio)
1129
 
        sio.seek(0)
1130
 
        self._transport.put_file('inventory', sio,
1131
 
            mode=self.bzrdir._get_file_mode())
1132
 
        self._inventory_is_modified = False
 
886
        """Write the in memory meta data to disk."""
 
887
        raise NotImplementedError(self.flush)
1133
888
 
1134
889
    def _kind(self, relpath):
1135
890
        return osutils.file_kind(self.abspath(relpath))
1145
900
        :param from_dir: start from this directory or None for the root
1146
901
        :param recursive: whether to recurse into subdirectories or not
1147
902
        """
1148
 
        # list_files is an iterator, so @needs_read_lock doesn't work properly
1149
 
        # with it. So callers should be careful to always read_lock the tree.
1150
 
        if not self.is_locked():
1151
 
            raise errors.ObjectNotLocked(self)
1152
 
 
1153
 
        inv = self.inventory
1154
 
        if from_dir is None and include_root is True:
1155
 
            yield ('', 'V', 'directory', inv.root.file_id, inv.root)
1156
 
        # Convert these into local objects to save lookup times
1157
 
        pathjoin = osutils.pathjoin
1158
 
        file_kind = self._kind
1159
 
 
1160
 
        # transport.base ends in a slash, we want the piece
1161
 
        # between the last two slashes
1162
 
        transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
1163
 
 
1164
 
        fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
1165
 
 
1166
 
        # directory file_id, relative path, absolute path, reverse sorted children
1167
 
        if from_dir is not None:
1168
 
            from_dir_id = inv.path2id(from_dir)
1169
 
            if from_dir_id is None:
1170
 
                # Directory not versioned
1171
 
                return
1172
 
            from_dir_abspath = pathjoin(self.basedir, from_dir)
1173
 
        else:
1174
 
            from_dir_id = inv.root.file_id
1175
 
            from_dir_abspath = self.basedir
1176
 
        children = os.listdir(from_dir_abspath)
1177
 
        children.sort()
1178
 
        # jam 20060527 The kernel sized tree seems equivalent whether we
1179
 
        # use a deque and popleft to keep them sorted, or if we use a plain
1180
 
        # list and just reverse() them.
1181
 
        children = collections.deque(children)
1182
 
        stack = [(from_dir_id, u'', from_dir_abspath, children)]
1183
 
        while stack:
1184
 
            from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
1185
 
 
1186
 
            while children:
1187
 
                f = children.popleft()
1188
 
                ## TODO: If we find a subdirectory with its own .bzr
1189
 
                ## directory, then that is a separate tree and we
1190
 
                ## should exclude it.
1191
 
 
1192
 
                # the bzrdir for this tree
1193
 
                if transport_base_dir == f:
1194
 
                    continue
1195
 
 
1196
 
                # we know that from_dir_relpath and from_dir_abspath never end in a slash
1197
 
                # and 'f' doesn't begin with one, we can do a string op, rather
1198
 
                # than the checks of pathjoin(), all relative paths will have an extra slash
1199
 
                # at the beginning
1200
 
                fp = from_dir_relpath + '/' + f
1201
 
 
1202
 
                # absolute path
1203
 
                fap = from_dir_abspath + '/' + f
1204
 
 
1205
 
                f_ie = inv.get_child(from_dir_id, f)
1206
 
                if f_ie:
1207
 
                    c = 'V'
1208
 
                elif self.is_ignored(fp[1:]):
1209
 
                    c = 'I'
1210
 
                else:
1211
 
                    # we may not have found this file, because of a unicode issue
1212
 
                    f_norm, can_access = osutils.normalized_filename(f)
1213
 
                    if f == f_norm or not can_access:
1214
 
                        # No change, so treat this file normally
1215
 
                        c = '?'
1216
 
                    else:
1217
 
                        # this file can be accessed by a normalized path
1218
 
                        # check again if it is versioned
1219
 
                        # these lines are repeated here for performance
1220
 
                        f = f_norm
1221
 
                        fp = from_dir_relpath + '/' + f
1222
 
                        fap = from_dir_abspath + '/' + f
1223
 
                        f_ie = inv.get_child(from_dir_id, f)
1224
 
                        if f_ie:
1225
 
                            c = 'V'
1226
 
                        elif self.is_ignored(fp[1:]):
1227
 
                            c = 'I'
1228
 
                        else:
1229
 
                            c = '?'
1230
 
 
1231
 
                fk = file_kind(fap)
1232
 
 
1233
 
                # make a last minute entry
1234
 
                if f_ie:
1235
 
                    yield fp[1:], c, fk, f_ie.file_id, f_ie
1236
 
                else:
1237
 
                    try:
1238
 
                        yield fp[1:], c, fk, None, fk_entries[fk]()
1239
 
                    except KeyError:
1240
 
                        yield fp[1:], c, fk, None, TreeEntry()
1241
 
                    continue
1242
 
 
1243
 
                if fk != 'directory':
1244
 
                    continue
1245
 
 
1246
 
                # But do this child first if recursing down
1247
 
                if recursive:
1248
 
                    new_children = os.listdir(fap)
1249
 
                    new_children.sort()
1250
 
                    new_children = collections.deque(new_children)
1251
 
                    stack.append((f_ie.file_id, fp, fap, new_children))
1252
 
                    # Break out of inner loop,
1253
 
                    # so that we start outer loop with child
1254
 
                    break
1255
 
            else:
1256
 
                # if we finished all children, pop it off the stack
1257
 
                stack.pop()
1258
 
 
1259
 
    @needs_tree_write_lock
1260
 
    def move(self, from_paths, to_dir=None, after=False, **kwargs):
 
903
        raise NotImplementedError(self.list_files)
 
904
 
 
905
    def move(self, from_paths, to_dir=None, after=False):
1261
906
        """Rename files.
1262
907
 
1263
 
        to_dir must exist in the inventory.
 
908
        to_dir must be known to the working tree.
1264
909
 
1265
910
        If to_dir exists and is a directory, the files are moved into
1266
911
        it, keeping their old names.
1272
917
        independently.
1273
918
 
1274
919
        The first mode moves the file in the filesystem and updates the
1275
 
        inventory. The second mode only updates the inventory without
1276
 
        touching the file on the filesystem. This is the new mode introduced
1277
 
        in version 0.15.
 
920
        working tree metadata. The second mode only updates the working tree
 
921
        metadata without touching the file on the filesystem.
1278
922
 
1279
923
        move uses the second mode if 'after == True' and the target is not
1280
924
        versioned but present in the working tree.
1292
936
        This returns a list of (from_path, to_path) pairs for each
1293
937
        entry that is moved.
1294
938
        """
1295
 
        rename_entries = []
1296
 
        rename_tuples = []
1297
 
 
1298
 
        # check for deprecated use of signature
1299
 
        if to_dir is None:
1300
 
            to_dir = kwargs.get('to_name', None)
1301
 
            if to_dir is None:
1302
 
                raise TypeError('You must supply a target directory')
1303
 
            else:
1304
 
                symbol_versioning.warn('The parameter to_name was deprecated'
1305
 
                                       ' in version 0.13. Use to_dir instead',
1306
 
                                       DeprecationWarning)
1307
 
 
1308
 
        # check destination directory
1309
 
        if isinstance(from_paths, basestring):
1310
 
            raise ValueError()
1311
 
        inv = self.inventory
1312
 
        to_abs = self.abspath(to_dir)
1313
 
        if not isdir(to_abs):
1314
 
            raise errors.BzrMoveFailedError('',to_dir,
1315
 
                errors.NotADirectory(to_abs))
1316
 
        if not self.has_filename(to_dir):
1317
 
            raise errors.BzrMoveFailedError('',to_dir,
1318
 
                errors.NotInWorkingDirectory(to_dir))
1319
 
        to_dir_id = inv.path2id(to_dir)
1320
 
        if to_dir_id is None:
1321
 
            raise errors.BzrMoveFailedError('',to_dir,
1322
 
                errors.NotVersionedError(path=str(to_dir)))
1323
 
 
1324
 
        to_dir_ie = inv[to_dir_id]
1325
 
        if to_dir_ie.kind != 'directory':
1326
 
            raise errors.BzrMoveFailedError('',to_dir,
1327
 
                errors.NotADirectory(to_abs))
1328
 
 
1329
 
        # create rename entries and tuples
1330
 
        for from_rel in from_paths:
1331
 
            from_tail = splitpath(from_rel)[-1]
1332
 
            from_id = inv.path2id(from_rel)
1333
 
            if from_id is None:
1334
 
                raise errors.BzrMoveFailedError(from_rel,to_dir,
1335
 
                    errors.NotVersionedError(path=str(from_rel)))
1336
 
 
1337
 
            from_entry = inv[from_id]
1338
 
            from_parent_id = from_entry.parent_id
1339
 
            to_rel = pathjoin(to_dir, from_tail)
1340
 
            rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1341
 
                                         from_id=from_id,
1342
 
                                         from_tail=from_tail,
1343
 
                                         from_parent_id=from_parent_id,
1344
 
                                         to_rel=to_rel, to_tail=from_tail,
1345
 
                                         to_parent_id=to_dir_id)
1346
 
            rename_entries.append(rename_entry)
1347
 
            rename_tuples.append((from_rel, to_rel))
1348
 
 
1349
 
        # determine which move mode to use. checks also for movability
1350
 
        rename_entries = self._determine_mv_mode(rename_entries, after)
1351
 
 
1352
 
        original_modified = self._inventory_is_modified
1353
 
        try:
1354
 
            if len(from_paths):
1355
 
                self._inventory_is_modified = True
1356
 
            self._move(rename_entries)
1357
 
        except:
1358
 
            # restore the inventory on error
1359
 
            self._inventory_is_modified = original_modified
1360
 
            raise
1361
 
        self._write_inventory(inv)
1362
 
        return rename_tuples
1363
 
 
1364
 
    def _determine_mv_mode(self, rename_entries, after=False):
1365
 
        """Determines for each from-to pair if both inventory and working tree
1366
 
        or only the inventory has to be changed.
1367
 
 
1368
 
        Also does basic plausability tests.
1369
 
        """
1370
 
        inv = self.inventory
1371
 
 
1372
 
        for rename_entry in rename_entries:
1373
 
            # store to local variables for easier reference
1374
 
            from_rel = rename_entry.from_rel
1375
 
            from_id = rename_entry.from_id
1376
 
            to_rel = rename_entry.to_rel
1377
 
            to_id = inv.path2id(to_rel)
1378
 
            only_change_inv = False
1379
 
 
1380
 
            # check the inventory for source and destination
1381
 
            if from_id is None:
1382
 
                raise errors.BzrMoveFailedError(from_rel,to_rel,
1383
 
                    errors.NotVersionedError(path=str(from_rel)))
1384
 
            if to_id is not None:
1385
 
                raise errors.BzrMoveFailedError(from_rel,to_rel,
1386
 
                    errors.AlreadyVersionedError(path=str(to_rel)))
1387
 
 
1388
 
            # try to determine the mode for rename (only change inv or change
1389
 
            # inv and file system)
1390
 
            if after:
1391
 
                if not self.has_filename(to_rel):
1392
 
                    raise errors.BzrMoveFailedError(from_id,to_rel,
1393
 
                        errors.NoSuchFile(path=str(to_rel),
1394
 
                        extra="New file has not been created yet"))
1395
 
                only_change_inv = True
1396
 
            elif not self.has_filename(from_rel) and self.has_filename(to_rel):
1397
 
                only_change_inv = True
1398
 
            elif self.has_filename(from_rel) and not self.has_filename(to_rel):
1399
 
                only_change_inv = False
1400
 
            elif (not self.case_sensitive
1401
 
                  and from_rel.lower() == to_rel.lower()
1402
 
                  and self.has_filename(from_rel)):
1403
 
                only_change_inv = False
1404
 
            else:
1405
 
                # something is wrong, so lets determine what exactly
1406
 
                if not self.has_filename(from_rel) and \
1407
 
                   not self.has_filename(to_rel):
1408
 
                    raise errors.BzrRenameFailedError(from_rel,to_rel,
1409
 
                        errors.PathsDoNotExist(paths=(str(from_rel),
1410
 
                        str(to_rel))))
1411
 
                else:
1412
 
                    raise errors.RenameFailedFilesExist(from_rel, to_rel)
1413
 
            rename_entry.only_change_inv = only_change_inv
1414
 
        return rename_entries
1415
 
 
1416
 
    def _move(self, rename_entries):
1417
 
        """Moves a list of files.
1418
 
 
1419
 
        Depending on the value of the flag 'only_change_inv', the
1420
 
        file will be moved on the file system or not.
1421
 
        """
1422
 
        inv = self.inventory
1423
 
        moved = []
1424
 
 
1425
 
        for entry in rename_entries:
1426
 
            try:
1427
 
                self._move_entry(entry)
1428
 
            except:
1429
 
                self._rollback_move(moved)
1430
 
                raise
1431
 
            moved.append(entry)
1432
 
 
1433
 
    def _rollback_move(self, moved):
1434
 
        """Try to rollback a previous move in case of an filesystem error."""
1435
 
        inv = self.inventory
1436
 
        for entry in moved:
1437
 
            try:
1438
 
                self._move_entry(WorkingTree._RenameEntry(
1439
 
                    entry.to_rel, entry.from_id,
1440
 
                    entry.to_tail, entry.to_parent_id, entry.from_rel,
1441
 
                    entry.from_tail, entry.from_parent_id,
1442
 
                    entry.only_change_inv))
1443
 
            except errors.BzrMoveFailedError, e:
1444
 
                raise errors.BzrMoveFailedError( '', '', "Rollback failed."
1445
 
                        " The working tree is in an inconsistent state."
1446
 
                        " Please consider doing a 'bzr revert'."
1447
 
                        " Error message is: %s" % e)
1448
 
 
1449
 
    def _move_entry(self, entry):
1450
 
        inv = self.inventory
1451
 
        from_rel_abs = self.abspath(entry.from_rel)
1452
 
        to_rel_abs = self.abspath(entry.to_rel)
1453
 
        if from_rel_abs == to_rel_abs:
1454
 
            raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
1455
 
                "Source and target are identical.")
1456
 
 
1457
 
        if not entry.only_change_inv:
1458
 
            try:
1459
 
                osutils.rename(from_rel_abs, to_rel_abs)
1460
 
            except OSError, e:
1461
 
                raise errors.BzrMoveFailedError(entry.from_rel,
1462
 
                    entry.to_rel, e[1])
1463
 
        inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
 
939
        raise NotImplementedError(self.move)
1464
940
 
1465
941
    @needs_tree_write_lock
1466
942
    def rename_one(self, from_rel, to_rel, after=False):
1470
946
 
1471
947
        rename_one has several 'modes' to work. First, it can rename a physical
1472
948
        file and change the file_id. That is the normal mode. Second, it can
1473
 
        only change the file_id without touching any physical file. This is
1474
 
        the new mode introduced in version 0.15.
 
949
        only change the file_id without touching any physical file.
1475
950
 
1476
 
        rename_one uses the second mode if 'after == True' and 'to_rel' is not
1477
 
        versioned but present in the working tree.
 
951
        rename_one uses the second mode if 'after == True' and 'to_rel' is
 
952
        either not versioned or newly added, and present in the working tree.
1478
953
 
1479
954
        rename_one uses the second mode if 'after == False' and 'from_rel' is
1480
955
        versioned but no longer in the working tree, and 'to_rel' is not
1486
961
 
1487
962
        Everything else results in an error.
1488
963
        """
1489
 
        inv = self.inventory
1490
 
        rename_entries = []
1491
 
 
1492
 
        # create rename entries and tuples
1493
 
        from_tail = splitpath(from_rel)[-1]
1494
 
        from_id = inv.path2id(from_rel)
1495
 
        if from_id is None:
1496
 
            # if file is missing in the inventory maybe it's in the basis_tree
1497
 
            basis_tree = self.branch.basis_tree()
1498
 
            from_id = basis_tree.path2id(from_rel)
1499
 
            if from_id is None:
1500
 
                raise errors.BzrRenameFailedError(from_rel,to_rel,
1501
 
                    errors.NotVersionedError(path=str(from_rel)))
1502
 
            # put entry back in the inventory so we can rename it
1503
 
            from_entry = basis_tree.inventory[from_id].copy()
1504
 
            inv.add(from_entry)
1505
 
        else:
1506
 
            from_entry = inv[from_id]
1507
 
        from_parent_id = from_entry.parent_id
1508
 
        to_dir, to_tail = os.path.split(to_rel)
1509
 
        to_dir_id = inv.path2id(to_dir)
1510
 
        rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1511
 
                                     from_id=from_id,
1512
 
                                     from_tail=from_tail,
1513
 
                                     from_parent_id=from_parent_id,
1514
 
                                     to_rel=to_rel, to_tail=to_tail,
1515
 
                                     to_parent_id=to_dir_id)
1516
 
        rename_entries.append(rename_entry)
1517
 
 
1518
 
        # determine which move mode to use. checks also for movability
1519
 
        rename_entries = self._determine_mv_mode(rename_entries, after)
1520
 
 
1521
 
        # check if the target changed directory and if the target directory is
1522
 
        # versioned
1523
 
        if to_dir_id is None:
1524
 
            raise errors.BzrMoveFailedError(from_rel,to_rel,
1525
 
                errors.NotVersionedError(path=str(to_dir)))
1526
 
 
1527
 
        # all checks done. now we can continue with our actual work
1528
 
        mutter('rename_one:\n'
1529
 
               '  from_id   {%s}\n'
1530
 
               '  from_rel: %r\n'
1531
 
               '  to_rel:   %r\n'
1532
 
               '  to_dir    %r\n'
1533
 
               '  to_dir_id {%s}\n',
1534
 
               from_id, from_rel, to_rel, to_dir, to_dir_id)
1535
 
 
1536
 
        self._move(rename_entries)
1537
 
        self._write_inventory(inv)
1538
 
 
1539
 
    class _RenameEntry(object):
1540
 
        def __init__(self, from_rel, from_id, from_tail, from_parent_id,
1541
 
                     to_rel, to_tail, to_parent_id, only_change_inv=False):
1542
 
            self.from_rel = from_rel
1543
 
            self.from_id = from_id
1544
 
            self.from_tail = from_tail
1545
 
            self.from_parent_id = from_parent_id
1546
 
            self.to_rel = to_rel
1547
 
            self.to_tail = to_tail
1548
 
            self.to_parent_id = to_parent_id
1549
 
            self.only_change_inv = only_change_inv
 
964
        raise NotImplementedError(self.rename_one)
1550
965
 
1551
966
    @needs_read_lock
1552
967
    def unknowns(self):
1560
975
        return iter(
1561
976
            [subp for subp in self.extras() if not self.is_ignored(subp)])
1562
977
 
1563
 
    @needs_tree_write_lock
1564
978
    def unversion(self, file_ids):
1565
979
        """Remove the file ids in file_ids from the current versioned set.
1566
980
 
1570
984
        :param file_ids: The file ids to stop versioning.
1571
985
        :raises: NoSuchId if any fileid is not currently versioned.
1572
986
        """
1573
 
        for file_id in file_ids:
1574
 
            if file_id not in self._inventory:
1575
 
                raise errors.NoSuchId(self, file_id)
1576
 
        for file_id in file_ids:
1577
 
            if self._inventory.has_id(file_id):
1578
 
                self._inventory.remove_recursive_id(file_id)
1579
 
        if len(file_ids):
1580
 
            # in the future this should just set a dirty bit to wait for the
1581
 
            # final unlock. However, until all methods of workingtree start
1582
 
            # with the current in -memory inventory rather than triggering
1583
 
            # a read, it is more complex - we need to teach read_inventory
1584
 
            # to know when to read, and when to not read first... and possibly
1585
 
            # to save first when the in memory one may be corrupted.
1586
 
            # so for now, we just only write it if it is indeed dirty.
1587
 
            # - RBC 20060907
1588
 
            self._write_inventory(self._inventory)
1589
 
 
1590
 
    def _iter_conflicts(self):
1591
 
        conflicted = set()
1592
 
        for info in self.list_files():
1593
 
            path = info[0]
1594
 
            stem = get_conflicted_stem(path)
1595
 
            if stem is None:
1596
 
                continue
1597
 
            if stem not in conflicted:
1598
 
                conflicted.add(stem)
1599
 
                yield stem
 
987
        raise NotImplementedError(self.unversion)
1600
988
 
1601
989
    @needs_write_lock
1602
990
    def pull(self, source, overwrite=False, stop_revision=None,
1603
 
             change_reporter=None, possible_transports=None, local=False):
 
991
             change_reporter=None, possible_transports=None, local=False,
 
992
             show_base=False):
1604
993
        source.lock_read()
1605
994
        try:
1606
995
            old_revision_info = self.branch.last_revision_info()
1611
1000
            new_revision_info = self.branch.last_revision_info()
1612
1001
            if new_revision_info != old_revision_info:
1613
1002
                repository = self.branch.repository
 
1003
                if repository._format.fast_deltas:
 
1004
                    parent_ids = self.get_parent_ids()
 
1005
                    if parent_ids:
 
1006
                        basis_id = parent_ids[0]
 
1007
                        basis_tree = repository.revision_tree(basis_id)
1614
1008
                basis_tree.lock_read()
1615
1009
                try:
1616
1010
                    new_basis_tree = self.branch.basis_tree()
1620
1014
                                basis_tree,
1621
1015
                                this_tree=self,
1622
1016
                                pb=None,
1623
 
                                change_reporter=change_reporter)
 
1017
                                change_reporter=change_reporter,
 
1018
                                show_base=show_base)
1624
1019
                    basis_root_id = basis_tree.get_root_id()
1625
1020
                    new_root_id = new_basis_tree.get_root_id()
1626
 
                    if basis_root_id != new_root_id:
 
1021
                    if new_root_id is not None and basis_root_id != new_root_id:
1627
1022
                        self.set_root_id(new_root_id)
1628
1023
                finally:
1629
1024
                    basis_tree.unlock()
1630
1025
                # TODO - dedup parents list with things merged by pull ?
1631
1026
                # reuse the revisiontree we merged against to set the new
1632
1027
                # tree data.
1633
 
                parent_trees = [(self.branch.last_revision(), new_basis_tree)]
 
1028
                parent_trees = []
 
1029
                if self.branch.last_revision() != _mod_revision.NULL_REVISION:
 
1030
                    parent_trees.append(
 
1031
                        (self.branch.last_revision(), new_basis_tree))
1634
1032
                # we have to pull the merge trees out again, because
1635
1033
                # merge_inner has set the ids. - this corner is not yet
1636
1034
                # layered well enough to prevent double handling.
1653
1051
            stream.write(bytes)
1654
1052
        finally:
1655
1053
            stream.close()
1656
 
        # TODO: update the hashcache here ?
1657
1054
 
1658
1055
    def extras(self):
1659
1056
        """Yield all unversioned files in this WorkingTree.
1665
1062
        Currently returned depth-first, sorted by name within directories.
1666
1063
        This is the same order used by 'osutils.walkdirs'.
1667
1064
        """
1668
 
        ## TODO: Work from given directory downwards
1669
 
        for path, dir_entry in self.inventory.directories():
1670
 
            # mutter("search for unknowns in %r", path)
1671
 
            dirabs = self.abspath(path)
1672
 
            if not isdir(dirabs):
1673
 
                # e.g. directory deleted
1674
 
                continue
1675
 
 
1676
 
            fl = []
1677
 
            for subf in os.listdir(dirabs):
1678
 
                if self.bzrdir.is_control_filename(subf):
1679
 
                    continue
1680
 
                if subf not in dir_entry.children:
1681
 
                    try:
1682
 
                        (subf_norm,
1683
 
                         can_access) = osutils.normalized_filename(subf)
1684
 
                    except UnicodeDecodeError:
1685
 
                        path_os_enc = path.encode(osutils._fs_enc)
1686
 
                        relpath = path_os_enc + '/' + subf
1687
 
                        raise errors.BadFilenameEncoding(relpath,
1688
 
                                                         osutils._fs_enc)
1689
 
                    if subf_norm != subf and can_access:
1690
 
                        if subf_norm not in dir_entry.children:
1691
 
                            fl.append(subf_norm)
1692
 
                    else:
1693
 
                        fl.append(subf)
1694
 
 
1695
 
            fl.sort()
1696
 
            for subf in fl:
1697
 
                subp = pathjoin(path, subf)
1698
 
                yield subp
 
1065
        raise NotImplementedError(self.extras)
1699
1066
 
1700
1067
    def ignored_files(self):
1701
1068
        """Yield list of PATH, IGNORE_PATTERN"""
1716
1083
        ignore_globs = set()
1717
1084
        ignore_globs.update(ignores.get_runtime_ignores())
1718
1085
        ignore_globs.update(ignores.get_user_ignores())
1719
 
        if self.has_filename(bzrlib.IGNORE_FILENAME):
1720
 
            f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
 
1086
        if self.has_filename(brzlib.IGNORE_FILENAME):
 
1087
            f = self.get_file_byname(brzlib.IGNORE_FILENAME)
1721
1088
            try:
1722
1089
                ignore_globs.update(ignores.parse_ignore_file(f))
1723
1090
            finally:
1750
1117
 
1751
1118
    def stored_kind(self, file_id):
1752
1119
        """See Tree.stored_kind"""
1753
 
        return self.inventory[file_id].kind
 
1120
        raise NotImplementedError(self.stored_kind)
1754
1121
 
1755
1122
    def _comparison_data(self, entry, path):
1756
1123
        abspath = self.abspath(path)
1766
1133
        else:
1767
1134
            mode = stat_value.st_mode
1768
1135
            kind = osutils.file_kind_from_stat_mode(mode)
1769
 
            if not supports_executable():
 
1136
            if not self._supports_executable():
1770
1137
                executable = entry is not None and entry.executable
1771
1138
            else:
1772
1139
                executable = bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
1791
1158
        return _mod_revision.ensure_null(self.branch.last_revision())
1792
1159
 
1793
1160
    def is_locked(self):
1794
 
        return self._control_files.is_locked()
1795
 
 
1796
 
    def _must_be_locked(self):
1797
 
        if not self.is_locked():
1798
 
            raise errors.ObjectNotLocked(self)
 
1161
        """Check if this tree is locked."""
 
1162
        raise NotImplementedError(self.is_locked)
1799
1163
 
1800
1164
    def lock_read(self):
1801
1165
        """Lock the tree for reading.
1802
1166
 
1803
1167
        This also locks the branch, and can be unlocked via self.unlock().
1804
1168
 
1805
 
        :return: An object with an unlock method which will release the lock
1806
 
            obtained.
 
1169
        :return: A brzlib.lock.LogicalLockResult.
1807
1170
        """
1808
 
        if not self.is_locked():
1809
 
            self._reset_data()
1810
 
        self.branch.lock_read()
1811
 
        try:
1812
 
            self._control_files.lock_read()
1813
 
            return self
1814
 
        except:
1815
 
            self.branch.unlock()
1816
 
            raise
 
1171
        raise NotImplementedError(self.lock_read)
1817
1172
 
1818
1173
    def lock_tree_write(self):
1819
1174
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
1820
1175
 
1821
 
        :return: An object with an unlock method which will release the lock
1822
 
            obtained.
 
1176
        :return: A brzlib.lock.LogicalLockResult.
1823
1177
        """
1824
 
        if not self.is_locked():
1825
 
            self._reset_data()
1826
 
        self.branch.lock_read()
1827
 
        try:
1828
 
            self._control_files.lock_write()
1829
 
            return self
1830
 
        except:
1831
 
            self.branch.unlock()
1832
 
            raise
 
1178
        raise NotImplementedError(self.lock_tree_write)
1833
1179
 
1834
1180
    def lock_write(self):
1835
1181
        """See MutableTree.lock_write, and WorkingTree.unlock.
1836
1182
 
1837
 
        :return: An object with an unlock method which will release the lock
1838
 
            obtained.
 
1183
        :return: A brzlib.lock.LogicalLockResult.
1839
1184
        """
1840
 
        if not self.is_locked():
1841
 
            self._reset_data()
1842
 
        self.branch.lock_write()
1843
 
        try:
1844
 
            self._control_files.lock_write()
1845
 
            return self
1846
 
        except:
1847
 
            self.branch.unlock()
1848
 
            raise
 
1185
        raise NotImplementedError(self.lock_write)
1849
1186
 
1850
1187
    def get_physical_lock_status(self):
1851
 
        return self._control_files.get_physical_lock_status()
1852
 
 
1853
 
    def _basis_inventory_name(self):
1854
 
        return 'basis-inventory-cache'
1855
 
 
1856
 
    def _reset_data(self):
1857
 
        """Reset transient data that cannot be revalidated."""
1858
 
        self._inventory_is_modified = False
1859
 
        f = self._transport.get('inventory')
1860
 
        try:
1861
 
            result = self._deserialize(f)
1862
 
        finally:
1863
 
            f.close()
1864
 
        self._set_inventory(result, dirty=False)
1865
 
 
1866
 
    @needs_tree_write_lock
 
1188
        raise NotImplementedError(self.get_physical_lock_status)
 
1189
 
1867
1190
    def set_last_revision(self, new_revision):
1868
1191
        """Change the last revision in the working tree."""
1869
 
        if self._change_last_revision(new_revision):
1870
 
            self._cache_basis_inventory(new_revision)
 
1192
        raise NotImplementedError(self.set_last_revision)
1871
1193
 
1872
1194
    def _change_last_revision(self, new_revision):
1873
1195
        """Template method part of set_last_revision to perform the change.
1876
1198
        when their last revision is set.
1877
1199
        """
1878
1200
        if _mod_revision.is_null(new_revision):
1879
 
            self.branch.set_revision_history([])
 
1201
            self.branch.set_last_revision_info(0, new_revision)
1880
1202
            return False
 
1203
        _mod_revision.check_not_reserved_id(new_revision)
1881
1204
        try:
1882
1205
            self.branch.generate_revision_history(new_revision)
1883
1206
        except errors.NoSuchRevision:
1884
1207
            # not present in the repo - dont try to set it deeper than the tip
1885
 
            self.branch.set_revision_history([new_revision])
 
1208
            self.branch._set_revision_history([new_revision])
1886
1209
        return True
1887
1210
 
1888
 
    def _write_basis_inventory(self, xml):
1889
 
        """Write the basis inventory XML to the basis-inventory file"""
1890
 
        path = self._basis_inventory_name()
1891
 
        sio = StringIO(xml)
1892
 
        self._transport.put_file(path, sio,
1893
 
            mode=self.bzrdir._get_file_mode())
1894
 
 
1895
 
    def _create_basis_xml_from_inventory(self, revision_id, inventory):
1896
 
        """Create the text that will be saved in basis-inventory"""
1897
 
        inventory.revision_id = revision_id
1898
 
        return xml7.serializer_v7.write_inventory_to_string(inventory)
1899
 
 
1900
 
    def _cache_basis_inventory(self, new_revision):
1901
 
        """Cache new_revision as the basis inventory."""
1902
 
        # TODO: this should allow the ready-to-use inventory to be passed in,
1903
 
        # as commit already has that ready-to-use [while the format is the
1904
 
        # same, that is].
1905
 
        try:
1906
 
            # this double handles the inventory - unpack and repack -
1907
 
            # but is easier to understand. We can/should put a conditional
1908
 
            # in here based on whether the inventory is in the latest format
1909
 
            # - perhaps we should repack all inventories on a repository
1910
 
            # upgrade ?
1911
 
            # the fast path is to copy the raw xml from the repository. If the
1912
 
            # xml contains 'revision_id="', then we assume the right
1913
 
            # revision_id is set. We must check for this full string, because a
1914
 
            # root node id can legitimately look like 'revision_id' but cannot
1915
 
            # contain a '"'.
1916
 
            xml = self.branch.repository._get_inventory_xml(new_revision)
1917
 
            firstline = xml.split('\n', 1)[0]
1918
 
            if (not 'revision_id="' in firstline or
1919
 
                'format="7"' not in firstline):
1920
 
                inv = self.branch.repository._serializer.read_inventory_from_string(
1921
 
                    xml, new_revision)
1922
 
                xml = self._create_basis_xml_from_inventory(new_revision, inv)
1923
 
            self._write_basis_inventory(xml)
1924
 
        except (errors.NoSuchRevision, errors.RevisionNotPresent):
1925
 
            pass
1926
 
 
1927
 
    def read_basis_inventory(self):
1928
 
        """Read the cached basis inventory."""
1929
 
        path = self._basis_inventory_name()
1930
 
        return self._transport.get_bytes(path)
1931
 
 
1932
 
    @needs_read_lock
1933
 
    def read_working_inventory(self):
1934
 
        """Read the working inventory.
1935
 
 
1936
 
        :raises errors.InventoryModified: read_working_inventory will fail
1937
 
            when the current in memory inventory has been modified.
1938
 
        """
1939
 
        # conceptually this should be an implementation detail of the tree.
1940
 
        # XXX: Deprecate this.
1941
 
        # ElementTree does its own conversion from UTF-8, so open in
1942
 
        # binary.
1943
 
        if self._inventory_is_modified:
1944
 
            raise errors.InventoryModified(self)
1945
 
        f = self._transport.get('inventory')
1946
 
        try:
1947
 
            result = self._deserialize(f)
1948
 
        finally:
1949
 
            f.close()
1950
 
        self._set_inventory(result, dirty=False)
1951
 
        return result
1952
 
 
1953
1211
    @needs_tree_write_lock
1954
1212
    def remove(self, files, verbose=False, to_file=None, keep_files=True,
1955
1213
        force=False):
1956
 
        """Remove nominated files from the working inventory.
 
1214
        """Remove nominated files from the working tree metadata.
1957
1215
 
1958
1216
        :files: File paths relative to the basedir.
1959
1217
        :keep_files: If true, the files will also be kept.
1965
1223
 
1966
1224
        inv_delta = []
1967
1225
 
1968
 
        new_files=set()
 
1226
        all_files = set() # specified and nested files 
1969
1227
        unknown_nested_files=set()
1970
1228
        if to_file is None:
1971
1229
            to_file = sys.stdout
1972
1230
 
 
1231
        files_to_backup = []
 
1232
 
1973
1233
        def recurse_directory_to_add_files(directory):
1974
1234
            # Recurse directory and add all files
1975
1235
            # so we can check if they have changed.
1976
 
            for parent_info, file_infos in\
1977
 
                self.walkdirs(directory):
 
1236
            for parent_info, file_infos in self.walkdirs(directory):
1978
1237
                for relpath, basename, kind, lstat, fileid, kind in file_infos:
1979
1238
                    # Is it versioned or ignored?
1980
 
                    if self.path2id(relpath) or self.is_ignored(relpath):
 
1239
                    if self.path2id(relpath):
1981
1240
                        # Add nested content for deletion.
1982
 
                        new_files.add(relpath)
 
1241
                        all_files.add(relpath)
1983
1242
                    else:
1984
 
                        # Files which are not versioned and not ignored
 
1243
                        # Files which are not versioned
1985
1244
                        # should be treated as unknown.
1986
 
                        unknown_nested_files.add((relpath, None, kind))
 
1245
                        files_to_backup.append(relpath)
1987
1246
 
1988
1247
        for filename in files:
1989
1248
            # Get file name into canonical form.
1990
1249
            abspath = self.abspath(filename)
1991
1250
            filename = self.relpath(abspath)
1992
1251
            if len(filename) > 0:
1993
 
                new_files.add(filename)
 
1252
                all_files.add(filename)
1994
1253
                recurse_directory_to_add_files(filename)
1995
1254
 
1996
 
        files = list(new_files)
 
1255
        files = list(all_files)
1997
1256
 
1998
1257
        if len(files) == 0:
1999
1258
            return # nothing to do
2003
1262
 
2004
1263
        # Bail out if we are going to delete files we shouldn't
2005
1264
        if not keep_files and not force:
2006
 
            has_changed_files = len(unknown_nested_files) > 0
2007
 
            if not has_changed_files:
2008
 
                for (file_id, path, content_change, versioned, parent_id, name,
2009
 
                     kind, executable) in self.iter_changes(self.basis_tree(),
2010
 
                         include_unchanged=True, require_versioned=False,
2011
 
                         want_unversioned=True, specific_files=files):
2012
 
                    if versioned == (False, False):
2013
 
                        # The record is unknown ...
2014
 
                        if not self.is_ignored(path[1]):
2015
 
                            # ... but not ignored
2016
 
                            has_changed_files = True
2017
 
                            break
2018
 
                    elif content_change and (kind[1] is not None):
2019
 
                        # Versioned and changed, but not deleted
2020
 
                        has_changed_files = True
2021
 
                        break
 
1265
            for (file_id, path, content_change, versioned, parent_id, name,
 
1266
                 kind, executable) in self.iter_changes(self.basis_tree(),
 
1267
                     include_unchanged=True, require_versioned=False,
 
1268
                     want_unversioned=True, specific_files=files):
 
1269
                if versioned[0] == False:
 
1270
                    # The record is unknown or newly added
 
1271
                    files_to_backup.append(path[1])
 
1272
                elif (content_change and (kind[1] is not None) and
 
1273
                        osutils.is_inside_any(files, path[1])):
 
1274
                    # Versioned and changed, but not deleted, and still
 
1275
                    # in one of the dirs to be deleted.
 
1276
                    files_to_backup.append(path[1])
2022
1277
 
2023
 
            if has_changed_files:
2024
 
                # Make delta show ALL applicable changes in error message.
2025
 
                tree_delta = self.changes_from(self.basis_tree(),
2026
 
                    require_versioned=False, want_unversioned=True,
2027
 
                    specific_files=files)
2028
 
                for unknown_file in unknown_nested_files:
2029
 
                    if unknown_file not in tree_delta.unversioned:
2030
 
                        tree_delta.unversioned.extend((unknown_file,))
2031
 
                raise errors.BzrRemoveChangedFilesError(tree_delta)
 
1278
        def backup(file_to_backup):
 
1279
            backup_name = self.bzrdir._available_backup_name(file_to_backup)
 
1280
            osutils.rename(abs_path, self.abspath(backup_name))
 
1281
            return "removed %s (but kept a copy: %s)" % (file_to_backup,
 
1282
                                                         backup_name)
2032
1283
 
2033
1284
        # Build inv_delta and delete files where applicable,
2034
 
        # do this before any modifications to inventory.
 
1285
        # do this before any modifications to meta data.
2035
1286
        for f in files:
2036
1287
            fid = self.path2id(f)
2037
1288
            message = None
2058
1309
                        len(os.listdir(abs_path)) > 0):
2059
1310
                        if force:
2060
1311
                            osutils.rmtree(abs_path)
 
1312
                            message = "deleted %s" % (f,)
2061
1313
                        else:
2062
 
                            message = "%s is not an empty directory "\
2063
 
                                "and won't be deleted." % (f,)
 
1314
                            message = backup(f)
2064
1315
                    else:
2065
 
                        osutils.delete_any(abs_path)
2066
 
                        message = "deleted %s" % (f,)
 
1316
                        if f in files_to_backup:
 
1317
                            message = backup(f)
 
1318
                        else:
 
1319
                            osutils.delete_any(abs_path)
 
1320
                            message = "deleted %s" % (f,)
2067
1321
                elif message is not None:
2068
1322
                    # Only care if we haven't done anything yet.
2069
1323
                    message = "%s does not exist." % (f,)
2076
1330
    @needs_tree_write_lock
2077
1331
    def revert(self, filenames=None, old_tree=None, backups=True,
2078
1332
               pb=None, report_changes=False):
2079
 
        from bzrlib.conflicts import resolve
2080
 
        if filenames == []:
2081
 
            filenames = None
2082
 
            symbol_versioning.warn('Using [] to revert all files is deprecated'
2083
 
                ' as of bzr 0.91.  Please use None (the default) instead.',
2084
 
                DeprecationWarning, stacklevel=2)
 
1333
        from brzlib.conflicts import resolve
2085
1334
        if old_tree is None:
2086
1335
            basis_tree = self.basis_tree()
2087
1336
            basis_tree.lock_read()
2108
1357
                basis_tree.unlock()
2109
1358
        return conflicts
2110
1359
 
 
1360
    @needs_write_lock
 
1361
    def store_uncommitted(self):
 
1362
        """Store uncommitted changes from the tree in the branch."""
 
1363
        target_tree = self.basis_tree()
 
1364
        shelf_creator = shelf.ShelfCreator(self, target_tree)
 
1365
        try:
 
1366
            if not shelf_creator.shelve_all():
 
1367
                return
 
1368
            self.branch.store_uncommitted(shelf_creator)
 
1369
            shelf_creator.transform()
 
1370
        finally:
 
1371
            shelf_creator.finalize()
 
1372
        note('Uncommitted changes stored in branch "%s".', self.branch.nick)
 
1373
 
 
1374
    @needs_write_lock
 
1375
    def restore_uncommitted(self):
 
1376
        """Restore uncommitted changes from the branch into the tree."""
 
1377
        unshelver = self.branch.get_unshelver(self)
 
1378
        if unshelver is None:
 
1379
            return
 
1380
        try:
 
1381
            merger = unshelver.make_merger()
 
1382
            merger.ignore_zero = True
 
1383
            merger.do_merge()
 
1384
            self.branch.store_uncommitted(None)
 
1385
        finally:
 
1386
            unshelver.finalize()
 
1387
 
2111
1388
    def revision_tree(self, revision_id):
2112
1389
        """See Tree.revision_tree.
2113
1390
 
2114
1391
        WorkingTree can supply revision_trees for the basis revision only
2115
1392
        because there is only one cached inventory in the bzr directory.
2116
1393
        """
2117
 
        if revision_id == self.last_revision():
2118
 
            try:
2119
 
                xml = self.read_basis_inventory()
2120
 
            except errors.NoSuchFile:
2121
 
                pass
2122
 
            else:
2123
 
                try:
2124
 
                    inv = xml7.serializer_v7.read_inventory_from_string(xml)
2125
 
                    # dont use the repository revision_tree api because we want
2126
 
                    # to supply the inventory.
2127
 
                    if inv.revision_id == revision_id:
2128
 
                        return revisiontree.RevisionTree(self.branch.repository,
2129
 
                            inv, revision_id)
2130
 
                except errors.BadInventoryFormat:
2131
 
                    pass
2132
 
        # raise if there was no inventory, or if we read the wrong inventory.
2133
 
        raise errors.NoSuchRevisionInTree(self, revision_id)
2134
 
 
2135
 
    # XXX: This method should be deprecated in favour of taking in a proper
2136
 
    # new Inventory object.
2137
 
    @needs_tree_write_lock
2138
 
    def set_inventory(self, new_inventory_list):
2139
 
        from bzrlib.inventory import (Inventory,
2140
 
                                      InventoryDirectory,
2141
 
                                      InventoryFile,
2142
 
                                      InventoryLink)
2143
 
        inv = Inventory(self.get_root_id())
2144
 
        for path, file_id, parent, kind in new_inventory_list:
2145
 
            name = os.path.basename(path)
2146
 
            if name == "":
2147
 
                continue
2148
 
            # fixme, there should be a factory function inv,add_??
2149
 
            if kind == 'directory':
2150
 
                inv.add(InventoryDirectory(file_id, name, parent))
2151
 
            elif kind == 'file':
2152
 
                inv.add(InventoryFile(file_id, name, parent))
2153
 
            elif kind == 'symlink':
2154
 
                inv.add(InventoryLink(file_id, name, parent))
2155
 
            else:
2156
 
                raise errors.BzrError("unknown kind %r" % kind)
2157
 
        self._write_inventory(inv)
 
1394
        raise NotImplementedError(self.revision_tree)
2158
1395
 
2159
1396
    @needs_tree_write_lock
2160
1397
    def set_root_id(self, file_id):
2173
1410
            present in the current inventory or an error will occur. It must
2174
1411
            not be None, but rather a valid file id.
2175
1412
        """
2176
 
        inv = self._inventory
2177
 
        orig_root_id = inv.root.file_id
2178
 
        # TODO: it might be nice to exit early if there was nothing
2179
 
        # to do, saving us from trigger a sync on unlock.
2180
 
        self._inventory_is_modified = True
2181
 
        # we preserve the root inventory entry object, but
2182
 
        # unlinkit from the byid index
2183
 
        del inv._byid[inv.root.file_id]
2184
 
        inv.root.file_id = file_id
2185
 
        # and link it into the index with the new changed id.
2186
 
        inv._byid[inv.root.file_id] = inv.root
2187
 
        # and finally update all children to reference the new id.
2188
 
        # XXX: this should be safe to just look at the root.children
2189
 
        # list, not the WHOLE INVENTORY.
2190
 
        for fid in inv:
2191
 
            entry = inv[fid]
2192
 
            if entry.parent_id == orig_root_id:
2193
 
                entry.parent_id = inv.root.file_id
 
1413
        raise NotImplementedError(self._set_root_id)
2194
1414
 
2195
1415
    def unlock(self):
2196
1416
        """See Branch.unlock.
2206
1426
    _marker = object()
2207
1427
 
2208
1428
    def update(self, change_reporter=None, possible_transports=None,
2209
 
               revision=None, old_tip=_marker):
 
1429
               revision=None, old_tip=_marker, show_base=False):
2210
1430
        """Update a working tree along its branch.
2211
1431
 
2212
1432
        This will update the branch if its bound too, which means we have
2227
1447
        - Restore the wt.basis->wt.state changes.
2228
1448
 
2229
1449
        There isn't a single operation at the moment to do that, so we:
 
1450
 
2230
1451
        - Merge current state -> basis tree of the master w.r.t. the old tree
2231
1452
          basis.
2232
1453
        - Do a 'normal' merge of the old branch basis if it is relevant.
2249
1470
            else:
2250
1471
                if old_tip is self._marker:
2251
1472
                    old_tip = None
2252
 
            return self._update_tree(old_tip, change_reporter, revision)
 
1473
            return self._update_tree(old_tip, change_reporter, revision, show_base)
2253
1474
        finally:
2254
1475
            self.unlock()
2255
1476
 
2256
1477
    @needs_tree_write_lock
2257
 
    def _update_tree(self, old_tip=None, change_reporter=None, revision=None):
 
1478
    def _update_tree(self, old_tip=None, change_reporter=None, revision=None,
 
1479
                     show_base=False):
2258
1480
        """Update a tree to the master branch.
2259
1481
 
2260
1482
        :param old_tip: if supplied, the previous tip revision the branch,
2287
1509
            other_tree = self.branch.repository.revision_tree(old_tip)
2288
1510
            nb_conflicts = merge.merge_inner(self.branch, other_tree,
2289
1511
                                             base_tree, this_tree=self,
2290
 
                                             change_reporter=change_reporter)
 
1512
                                             change_reporter=change_reporter,
 
1513
                                             show_base=show_base)
2291
1514
            if nb_conflicts:
2292
1515
                self.add_parent_tree((old_tip, other_tree))
2293
 
                trace.note('Rerun update after fixing the conflicts.')
 
1516
                note(gettext('Rerun update after fixing the conflicts.'))
2294
1517
                return nb_conflicts
2295
1518
 
2296
1519
        if last_rev != _mod_revision.ensure_null(revision):
2302
1525
            basis = self.basis_tree()
2303
1526
            basis.lock_read()
2304
1527
            try:
2305
 
                if (basis.inventory.root is None
2306
 
                    or basis.inventory.root.file_id != to_root_id):
 
1528
                if (basis.get_root_id() is None or basis.get_root_id() != to_root_id):
2307
1529
                    self.set_root_id(to_root_id)
2308
1530
                    self.flush()
2309
1531
            finally:
2317
1539
 
2318
1540
            nb_conflicts = merge.merge_inner(self.branch, to_tree, base_tree,
2319
1541
                                             this_tree=self,
2320
 
                                             change_reporter=change_reporter)
 
1542
                                             change_reporter=change_reporter,
 
1543
                                             show_base=show_base)
2321
1544
            self.set_last_revision(revision)
2322
1545
            # TODO - dedup parents list with things merged by pull ?
2323
1546
            # reuse the tree we've updated to to set the basis:
2338
1561
            last_rev = parent_trees[0][0]
2339
1562
        return nb_conflicts
2340
1563
 
2341
 
    def _write_hashcache_if_dirty(self):
2342
 
        """Write out the hashcache if it is dirty."""
2343
 
        if self._hashcache.needs_write:
2344
 
            try:
2345
 
                self._hashcache.write()
2346
 
            except OSError, e:
2347
 
                if e.errno not in (errno.EPERM, errno.EACCES):
2348
 
                    raise
2349
 
                # TODO: jam 20061219 Should this be a warning? A single line
2350
 
                #       warning might be sufficient to let the user know what
2351
 
                #       is going on.
2352
 
                mutter('Could not write hashcache for %s\nError: %s',
2353
 
                       self._hashcache.cache_file_name(), e)
2354
 
 
2355
 
    @needs_tree_write_lock
2356
 
    def _write_inventory(self, inv):
2357
 
        """Write inventory as the current inventory."""
2358
 
        self._set_inventory(inv, dirty=True)
2359
 
        self.flush()
2360
 
 
2361
1564
    def set_conflicts(self, arg):
2362
1565
        raise errors.UnsupportedOperation(self.set_conflicts, self)
2363
1566
 
2364
1567
    def add_conflicts(self, arg):
2365
1568
        raise errors.UnsupportedOperation(self.add_conflicts, self)
2366
1569
 
2367
 
    @needs_read_lock
2368
1570
    def conflicts(self):
2369
 
        conflicts = _mod_conflicts.ConflictList()
2370
 
        for conflicted in self._iter_conflicts():
2371
 
            text = True
2372
 
            try:
2373
 
                if file_kind(self.abspath(conflicted)) != "file":
2374
 
                    text = False
2375
 
            except errors.NoSuchFile:
2376
 
                text = False
2377
 
            if text is True:
2378
 
                for suffix in ('.THIS', '.OTHER'):
2379
 
                    try:
2380
 
                        kind = file_kind(self.abspath(conflicted+suffix))
2381
 
                        if kind != "file":
2382
 
                            text = False
2383
 
                    except errors.NoSuchFile:
2384
 
                        text = False
2385
 
                    if text == False:
2386
 
                        break
2387
 
            ctype = {True: 'text conflict', False: 'contents conflict'}[text]
2388
 
            conflicts.append(_mod_conflicts.Conflict.factory(ctype,
2389
 
                             path=conflicted,
2390
 
                             file_id=self.path2id(conflicted)))
2391
 
        return conflicts
 
1571
        raise NotImplementedError(self.conflicts)
2392
1572
 
2393
1573
    def walkdirs(self, prefix=""):
2394
1574
        """Walk the directories of this tree.
2514
1694
    def _walkdirs(self, prefix=""):
2515
1695
        """Walk the directories of this tree.
2516
1696
 
2517
 
           :prefix: is used as the directrory to start with.
2518
 
           returns a generator which yields items in the form:
2519
 
                ((curren_directory_path, fileid),
2520
 
                 [(file1_path, file1_name, file1_kind, None, file1_id,
2521
 
                   file1_kind), ... ])
 
1697
        :param prefix: is used as the directrory to start with.
 
1698
        :returns: a generator which yields items in the form::
 
1699
 
 
1700
            ((curren_directory_path, fileid),
 
1701
             [(file1_path, file1_name, file1_kind, None, file1_id,
 
1702
               file1_kind), ... ])
2522
1703
        """
2523
 
        _directory = 'directory'
2524
 
        # get the root in the inventory
2525
 
        inv = self.inventory
2526
 
        top_id = inv.path2id(prefix)
2527
 
        if top_id is None:
2528
 
            pending = []
2529
 
        else:
2530
 
            pending = [(prefix, '', _directory, None, top_id, None)]
2531
 
        while pending:
2532
 
            dirblock = []
2533
 
            currentdir = pending.pop()
2534
 
            # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
2535
 
            top_id = currentdir[4]
2536
 
            if currentdir[0]:
2537
 
                relroot = currentdir[0] + '/'
2538
 
            else:
2539
 
                relroot = ""
2540
 
            # FIXME: stash the node in pending
2541
 
            entry = inv[top_id]
2542
 
            if entry.kind == 'directory':
2543
 
                for name, child in entry.sorted_children():
2544
 
                    dirblock.append((relroot + name, name, child.kind, None,
2545
 
                        child.file_id, child.kind
2546
 
                        ))
2547
 
            yield (currentdir[0], entry.file_id), dirblock
2548
 
            # push the user specified dirs from dirblock
2549
 
            for dir in reversed(dirblock):
2550
 
                if dir[2] == _directory:
2551
 
                    pending.append(dir)
 
1704
        raise NotImplementedError(self._walkdirs)
2552
1705
 
2553
1706
    @needs_tree_write_lock
2554
1707
    def auto_resolve(self):
2558
1711
        are considered 'resolved', because bzr always puts conflict markers
2559
1712
        into files that have text conflicts.  The corresponding .THIS .BASE and
2560
1713
        .OTHER files are deleted, as per 'resolve'.
 
1714
 
2561
1715
        :return: a tuple of ConflictLists: (un_resolved, resolved).
2562
1716
        """
2563
1717
        un_resolved = _mod_conflicts.ConflictList()
2582
1736
        self.set_conflicts(un_resolved)
2583
1737
        return un_resolved, resolved
2584
1738
 
2585
 
    @needs_read_lock
2586
 
    def _check(self, references):
2587
 
        """Check the tree for consistency.
2588
 
 
2589
 
        :param references: A dict with keys matching the items returned by
2590
 
            self._get_check_refs(), and values from looking those keys up in
2591
 
            the repository.
2592
 
        """
2593
 
        tree_basis = self.basis_tree()
2594
 
        tree_basis.lock_read()
2595
 
        try:
2596
 
            repo_basis = references[('trees', self.last_revision())]
2597
 
            if len(list(repo_basis.iter_changes(tree_basis))) > 0:
2598
 
                raise errors.BzrCheckError(
2599
 
                    "Mismatched basis inventory content.")
2600
 
            self._validate()
2601
 
        finally:
2602
 
            tree_basis.unlock()
2603
 
 
2604
1739
    def _validate(self):
2605
1740
        """Validate internal structures.
2606
1741
 
2612
1747
        """
2613
1748
        return
2614
1749
 
 
1750
    def check_state(self):
 
1751
        """Check that the working state is/isn't valid."""
 
1752
        raise NotImplementedError(self.check_state)
 
1753
 
 
1754
    def reset_state(self, revision_ids=None):
 
1755
        """Reset the state of the working tree.
 
1756
 
 
1757
        This does a hard-reset to a last-known-good state. This is a way to
 
1758
        fix if something got corrupted (like the .bzr/checkout/dirstate file)
 
1759
        """
 
1760
        raise NotImplementedError(self.reset_state)
 
1761
 
2615
1762
    def _get_rules_searcher(self, default_searcher):
2616
1763
        """See Tree._get_rules_searcher."""
2617
1764
        if self._rules_searcher is None:
2621
1768
 
2622
1769
    def get_shelf_manager(self):
2623
1770
        """Return the ShelfManager for this WorkingTree."""
2624
 
        from bzrlib.shelf import ShelfManager
 
1771
        from brzlib.shelf import ShelfManager
2625
1772
        return ShelfManager(self, self._transport)
2626
1773
 
2627
1774
 
2628
 
class WorkingTree2(WorkingTree):
2629
 
    """This is the Format 2 working tree.
2630
 
 
2631
 
    This was the first weave based working tree.
2632
 
     - uses os locks for locking.
2633
 
     - uses the branch last-revision.
 
1775
class InventoryWorkingTree(WorkingTree,
 
1776
        brzlib.mutabletree.MutableInventoryTree):
 
1777
    """Base class for working trees that are inventory-oriented.
 
1778
 
 
1779
    The inventory is held in the `Branch` working-inventory, and the
 
1780
    files are in a directory on disk.
 
1781
 
 
1782
    It is possible for a `WorkingTree` to have a filename which is
 
1783
    not listed in the Inventory and vice versa.
2634
1784
    """
2635
1785
 
2636
 
    def __init__(self, *args, **kwargs):
2637
 
        super(WorkingTree2, self).__init__(*args, **kwargs)
2638
 
        # WorkingTree2 has more of a constraint that self._inventory must
2639
 
        # exist. Because this is an older format, we don't mind the overhead
2640
 
        # caused by the extra computation here.
2641
 
 
2642
 
        # Newer WorkingTree's should only have self._inventory set when they
2643
 
        # have a read lock.
2644
 
        if self._inventory is None:
2645
 
            self.read_working_inventory()
2646
 
 
2647
 
    def _get_check_refs(self):
2648
 
        """Return the references needed to perform a check of this tree."""
2649
 
        return [('trees', self.last_revision())]
 
1786
    def __init__(self, basedir='.',
 
1787
                 branch=DEPRECATED_PARAMETER,
 
1788
                 _inventory=None,
 
1789
                 _control_files=None,
 
1790
                 _internal=False,
 
1791
                 _format=None,
 
1792
                 _bzrdir=None):
 
1793
        """Construct a InventoryWorkingTree instance. This is not a public API.
 
1794
 
 
1795
        :param branch: A branch to override probing for the branch.
 
1796
        """
 
1797
        super(InventoryWorkingTree, self).__init__(basedir=basedir,
 
1798
            branch=branch, _transport=_control_files._transport,
 
1799
            _internal=_internal, _format=_format, _bzrdir=_bzrdir)
 
1800
 
 
1801
        self._control_files = _control_files
 
1802
        self._detect_case_handling()
 
1803
 
 
1804
        if _inventory is None:
 
1805
            # This will be acquired on lock_read() or lock_write()
 
1806
            self._inventory_is_modified = False
 
1807
            self._inventory = None
 
1808
        else:
 
1809
            # the caller of __init__ has provided an inventory,
 
1810
            # we assume they know what they are doing - as its only
 
1811
            # the Format factory and creation methods that are
 
1812
            # permitted to do this.
 
1813
            self._set_inventory(_inventory, dirty=False)
 
1814
 
 
1815
    def _set_inventory(self, inv, dirty):
 
1816
        """Set the internal cached inventory.
 
1817
 
 
1818
        :param inv: The inventory to set.
 
1819
        :param dirty: A boolean indicating whether the inventory is the same
 
1820
            logical inventory as whats on disk. If True the inventory is not
 
1821
            the same and should be written to disk or data will be lost, if
 
1822
            False then the inventory is the same as that on disk and any
 
1823
            serialisation would be unneeded overhead.
 
1824
        """
 
1825
        self._inventory = inv
 
1826
        self._inventory_is_modified = dirty
 
1827
 
 
1828
    def _detect_case_handling(self):
 
1829
        wt_trans = self.bzrdir.get_workingtree_transport(None)
 
1830
        try:
 
1831
            wt_trans.stat(self._format.case_sensitive_filename)
 
1832
        except errors.NoSuchFile:
 
1833
            self.case_sensitive = True
 
1834
        else:
 
1835
            self.case_sensitive = False
 
1836
 
 
1837
        self._setup_directory_is_tree_reference()
 
1838
 
 
1839
    def _serialize(self, inventory, out_file):
 
1840
        xml5.serializer_v5.write_inventory(self._inventory, out_file,
 
1841
            working=True)
 
1842
 
 
1843
    def _deserialize(selt, in_file):
 
1844
        return xml5.serializer_v5.read_inventory(in_file)
 
1845
 
 
1846
    def break_lock(self):
 
1847
        """Break a lock if one is present from another instance.
 
1848
 
 
1849
        Uses the ui factory to ask for confirmation if the lock may be from
 
1850
        an active process.
 
1851
 
 
1852
        This will probe the repository for its lock as well.
 
1853
        """
 
1854
        self._control_files.break_lock()
 
1855
        self.branch.break_lock()
 
1856
 
 
1857
    def is_locked(self):
 
1858
        return self._control_files.is_locked()
 
1859
 
 
1860
    def _must_be_locked(self):
 
1861
        if not self.is_locked():
 
1862
            raise errors.ObjectNotLocked(self)
 
1863
 
 
1864
    def lock_read(self):
 
1865
        """Lock the tree for reading.
 
1866
 
 
1867
        This also locks the branch, and can be unlocked via self.unlock().
 
1868
 
 
1869
        :return: A brzlib.lock.LogicalLockResult.
 
1870
        """
 
1871
        if not self.is_locked():
 
1872
            self._reset_data()
 
1873
        self.branch.lock_read()
 
1874
        try:
 
1875
            self._control_files.lock_read()
 
1876
            return LogicalLockResult(self.unlock)
 
1877
        except:
 
1878
            self.branch.unlock()
 
1879
            raise
2650
1880
 
2651
1881
    def lock_tree_write(self):
2652
 
        """See WorkingTree.lock_tree_write().
2653
 
 
2654
 
        In Format2 WorkingTrees we have a single lock for the branch and tree
2655
 
        so lock_tree_write() degrades to lock_write().
2656
 
 
2657
 
        :return: An object with an unlock method which will release the lock
2658
 
            obtained.
2659
 
        """
 
1882
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
 
1883
 
 
1884
        :return: A brzlib.lock.LogicalLockResult.
 
1885
        """
 
1886
        if not self.is_locked():
 
1887
            self._reset_data()
 
1888
        self.branch.lock_read()
 
1889
        try:
 
1890
            self._control_files.lock_write()
 
1891
            return LogicalLockResult(self.unlock)
 
1892
        except:
 
1893
            self.branch.unlock()
 
1894
            raise
 
1895
 
 
1896
    def lock_write(self):
 
1897
        """See MutableTree.lock_write, and WorkingTree.unlock.
 
1898
 
 
1899
        :return: A brzlib.lock.LogicalLockResult.
 
1900
        """
 
1901
        if not self.is_locked():
 
1902
            self._reset_data()
2660
1903
        self.branch.lock_write()
2661
1904
        try:
2662
1905
            self._control_files.lock_write()
2663
 
            return self
 
1906
            return LogicalLockResult(self.unlock)
2664
1907
        except:
2665
1908
            self.branch.unlock()
2666
1909
            raise
2667
1910
 
2668
 
    def unlock(self):
2669
 
        # do non-implementation specific cleanup
2670
 
        self._cleanup()
2671
 
 
2672
 
        # we share control files:
2673
 
        if self._control_files._lock_count == 3:
2674
 
            # _inventory_is_modified is always False during a read lock.
2675
 
            if self._inventory_is_modified:
2676
 
                self.flush()
2677
 
            self._write_hashcache_if_dirty()
2678
 
 
2679
 
        # reverse order of locking.
 
1911
    def get_physical_lock_status(self):
 
1912
        return self._control_files.get_physical_lock_status()
 
1913
 
 
1914
    @needs_tree_write_lock
 
1915
    def _write_inventory(self, inv):
 
1916
        """Write inventory as the current inventory."""
 
1917
        self._set_inventory(inv, dirty=True)
 
1918
        self.flush()
 
1919
 
 
1920
    # XXX: This method should be deprecated in favour of taking in a proper
 
1921
    # new Inventory object.
 
1922
    @needs_tree_write_lock
 
1923
    def set_inventory(self, new_inventory_list):
 
1924
        from brzlib.inventory import (Inventory,
 
1925
                                      InventoryDirectory,
 
1926
                                      InventoryFile,
 
1927
                                      InventoryLink)
 
1928
        inv = Inventory(self.get_root_id())
 
1929
        for path, file_id, parent, kind in new_inventory_list:
 
1930
            name = os.path.basename(path)
 
1931
            if name == "":
 
1932
                continue
 
1933
            # fixme, there should be a factory function inv,add_??
 
1934
            if kind == 'directory':
 
1935
                inv.add(InventoryDirectory(file_id, name, parent))
 
1936
            elif kind == 'file':
 
1937
                inv.add(InventoryFile(file_id, name, parent))
 
1938
            elif kind == 'symlink':
 
1939
                inv.add(InventoryLink(file_id, name, parent))
 
1940
            else:
 
1941
                raise errors.BzrError("unknown kind %r" % kind)
 
1942
        self._write_inventory(inv)
 
1943
 
 
1944
    def _write_basis_inventory(self, xml):
 
1945
        """Write the basis inventory XML to the basis-inventory file"""
 
1946
        path = self._basis_inventory_name()
 
1947
        sio = StringIO(xml)
 
1948
        self._transport.put_file(path, sio,
 
1949
            mode=self.bzrdir._get_file_mode())
 
1950
 
 
1951
    def _reset_data(self):
 
1952
        """Reset transient data that cannot be revalidated."""
 
1953
        self._inventory_is_modified = False
 
1954
        f = self._transport.get('inventory')
2680
1955
        try:
2681
 
            return self._control_files.unlock()
 
1956
            result = self._deserialize(f)
2682
1957
        finally:
2683
 
            self.branch.unlock()
2684
 
 
2685
 
 
2686
 
class WorkingTree3(WorkingTree):
2687
 
    """This is the Format 3 working tree.
2688
 
 
2689
 
    This differs from the base WorkingTree by:
2690
 
     - having its own file lock
2691
 
     - having its own last-revision property.
2692
 
 
2693
 
    This is new in bzr 0.8
2694
 
    """
2695
 
 
2696
 
    @needs_read_lock
2697
 
    def _last_revision(self):
2698
 
        """See Mutable.last_revision."""
 
1958
            f.close()
 
1959
        self._set_inventory(result, dirty=False)
 
1960
 
 
1961
    def _set_root_id(self, file_id):
 
1962
        """Set the root id for this tree, in a format specific manner.
 
1963
 
 
1964
        :param file_id: The file id to assign to the root. It must not be
 
1965
            present in the current inventory or an error will occur. It must
 
1966
            not be None, but rather a valid file id.
 
1967
        """
 
1968
        inv = self._inventory
 
1969
        orig_root_id = inv.root.file_id
 
1970
        # TODO: it might be nice to exit early if there was nothing
 
1971
        # to do, saving us from trigger a sync on unlock.
 
1972
        self._inventory_is_modified = True
 
1973
        # we preserve the root inventory entry object, but
 
1974
        # unlinkit from the byid index
 
1975
        del inv._byid[inv.root.file_id]
 
1976
        inv.root.file_id = file_id
 
1977
        # and link it into the index with the new changed id.
 
1978
        inv._byid[inv.root.file_id] = inv.root
 
1979
        # and finally update all children to reference the new id.
 
1980
        # XXX: this should be safe to just look at the root.children
 
1981
        # list, not the WHOLE INVENTORY.
 
1982
        for fid in inv:
 
1983
            entry = inv[fid]
 
1984
            if entry.parent_id == orig_root_id:
 
1985
                entry.parent_id = inv.root.file_id
 
1986
 
 
1987
    @needs_tree_write_lock
 
1988
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
 
1989
        """See MutableTree.set_parent_trees."""
 
1990
        parent_ids = [rev for (rev, tree) in parents_list]
 
1991
        for revision_id in parent_ids:
 
1992
            _mod_revision.check_not_reserved_id(revision_id)
 
1993
 
 
1994
        self._check_parents_for_ghosts(parent_ids,
 
1995
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
1996
 
 
1997
        parent_ids = self._filter_parent_ids_by_ancestry(parent_ids)
 
1998
 
 
1999
        if len(parent_ids) == 0:
 
2000
            leftmost_parent_id = _mod_revision.NULL_REVISION
 
2001
            leftmost_parent_tree = None
 
2002
        else:
 
2003
            leftmost_parent_id, leftmost_parent_tree = parents_list[0]
 
2004
 
 
2005
        if self._change_last_revision(leftmost_parent_id):
 
2006
            if leftmost_parent_tree is None:
 
2007
                # If we don't have a tree, fall back to reading the
 
2008
                # parent tree from the repository.
 
2009
                self._cache_basis_inventory(leftmost_parent_id)
 
2010
            else:
 
2011
                inv = leftmost_parent_tree.root_inventory
 
2012
                xml = self._create_basis_xml_from_inventory(
 
2013
                                        leftmost_parent_id, inv)
 
2014
                self._write_basis_inventory(xml)
 
2015
        self._set_merges_from_parent_ids(parent_ids)
 
2016
 
 
2017
    def _cache_basis_inventory(self, new_revision):
 
2018
        """Cache new_revision as the basis inventory."""
 
2019
        # TODO: this should allow the ready-to-use inventory to be passed in,
 
2020
        # as commit already has that ready-to-use [while the format is the
 
2021
        # same, that is].
2699
2022
        try:
2700
 
            return self._transport.get_bytes('last-revision')
2701
 
        except errors.NoSuchFile:
2702
 
            return _mod_revision.NULL_REVISION
2703
 
 
2704
 
    def _change_last_revision(self, revision_id):
2705
 
        """See WorkingTree._change_last_revision."""
2706
 
        if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
2707
 
            try:
2708
 
                self._transport.delete('last-revision')
2709
 
            except errors.NoSuchFile:
2710
 
                pass
2711
 
            return False
2712
 
        else:
2713
 
            self._transport.put_bytes('last-revision', revision_id,
2714
 
                mode=self.bzrdir._get_file_mode())
2715
 
            return True
2716
 
 
2717
 
    def _get_check_refs(self):
2718
 
        """Return the references needed to perform a check of this tree."""
2719
 
        return [('trees', self.last_revision())]
 
2023
            # this double handles the inventory - unpack and repack -
 
2024
            # but is easier to understand. We can/should put a conditional
 
2025
            # in here based on whether the inventory is in the latest format
 
2026
            # - perhaps we should repack all inventories on a repository
 
2027
            # upgrade ?
 
2028
            # the fast path is to copy the raw xml from the repository. If the
 
2029
            # xml contains 'revision_id="', then we assume the right
 
2030
            # revision_id is set. We must check for this full string, because a
 
2031
            # root node id can legitimately look like 'revision_id' but cannot
 
2032
            # contain a '"'.
 
2033
            xml = self.branch.repository._get_inventory_xml(new_revision)
 
2034
            firstline = xml.split('\n', 1)[0]
 
2035
            if (not 'revision_id="' in firstline or
 
2036
                'format="7"' not in firstline):
 
2037
                inv = self.branch.repository._serializer.read_inventory_from_string(
 
2038
                    xml, new_revision)
 
2039
                xml = self._create_basis_xml_from_inventory(new_revision, inv)
 
2040
            self._write_basis_inventory(xml)
 
2041
        except (errors.NoSuchRevision, errors.RevisionNotPresent):
 
2042
            pass
 
2043
 
 
2044
    def _basis_inventory_name(self):
 
2045
        return 'basis-inventory-cache'
 
2046
 
 
2047
    def _create_basis_xml_from_inventory(self, revision_id, inventory):
 
2048
        """Create the text that will be saved in basis-inventory"""
 
2049
        inventory.revision_id = revision_id
 
2050
        return xml7.serializer_v7.write_inventory_to_string(inventory)
2720
2051
 
2721
2052
    @needs_tree_write_lock
2722
2053
    def set_conflicts(self, conflicts):
2742
2073
                    raise errors.ConflictFormatError()
2743
2074
            except StopIteration:
2744
2075
                raise errors.ConflictFormatError()
2745
 
            return _mod_conflicts.ConflictList.from_stanzas(RioReader(confile))
 
2076
            reader = _mod_rio.RioReader(confile)
 
2077
            return _mod_conflicts.ConflictList.from_stanzas(reader)
2746
2078
        finally:
2747
2079
            confile.close()
2748
2080
 
2749
 
    def unlock(self):
2750
 
        # do non-implementation specific cleanup
2751
 
        self._cleanup()
2752
 
        if self._control_files._lock_count == 1:
2753
 
            # _inventory_is_modified is always False during a read lock.
2754
 
            if self._inventory_is_modified:
2755
 
                self.flush()
2756
 
            self._write_hashcache_if_dirty()
2757
 
        # reverse order of locking.
2758
 
        try:
2759
 
            return self._control_files.unlock()
2760
 
        finally:
2761
 
            self.branch.unlock()
2762
 
 
2763
 
 
2764
 
def get_conflicted_stem(path):
2765
 
    for suffix in _mod_conflicts.CONFLICT_SUFFIXES:
2766
 
        if path.endswith(suffix):
2767
 
            return path[:-len(suffix)]
2768
 
 
2769
 
 
2770
 
class WorkingTreeFormat(object):
 
2081
    def read_basis_inventory(self):
 
2082
        """Read the cached basis inventory."""
 
2083
        path = self._basis_inventory_name()
 
2084
        return self._transport.get_bytes(path)
 
2085
 
 
2086
    @needs_read_lock
 
2087
    def read_working_inventory(self):
 
2088
        """Read the working inventory.
 
2089
 
 
2090
        :raises errors.InventoryModified: read_working_inventory will fail
 
2091
            when the current in memory inventory has been modified.
 
2092
        """
 
2093
        # conceptually this should be an implementation detail of the tree.
 
2094
        # XXX: Deprecate this.
 
2095
        # ElementTree does its own conversion from UTF-8, so open in
 
2096
        # binary.
 
2097
        if self._inventory_is_modified:
 
2098
            raise errors.InventoryModified(self)
 
2099
        f = self._transport.get('inventory')
 
2100
        try:
 
2101
            result = self._deserialize(f)
 
2102
        finally:
 
2103
            f.close()
 
2104
        self._set_inventory(result, dirty=False)
 
2105
        return result
 
2106
 
 
2107
    @needs_read_lock
 
2108
    def get_root_id(self):
 
2109
        """Return the id of this trees root"""
 
2110
        return self._inventory.root.file_id
 
2111
 
 
2112
    def has_id(self, file_id):
 
2113
        # files that have been deleted are excluded
 
2114
        inv, inv_file_id = self._unpack_file_id(file_id)
 
2115
        if not inv.has_id(inv_file_id):
 
2116
            return False
 
2117
        path = inv.id2path(inv_file_id)
 
2118
        return osutils.lexists(self.abspath(path))
 
2119
 
 
2120
    def has_or_had_id(self, file_id):
 
2121
        if file_id == self.get_root_id():
 
2122
            return True
 
2123
        inv, inv_file_id = self._unpack_file_id(file_id)
 
2124
        return inv.has_id(inv_file_id)
 
2125
 
 
2126
    def all_file_ids(self):
 
2127
        """Iterate through file_ids for this tree.
 
2128
 
 
2129
        file_ids are in a WorkingTree if they are in the working inventory
 
2130
        and the working file exists.
 
2131
        """
 
2132
        ret = set()
 
2133
        for path, ie in self.iter_entries_by_dir():
 
2134
            ret.add(ie.file_id)
 
2135
        return ret
 
2136
 
 
2137
    @needs_tree_write_lock
 
2138
    def set_last_revision(self, new_revision):
 
2139
        """Change the last revision in the working tree."""
 
2140
        if self._change_last_revision(new_revision):
 
2141
            self._cache_basis_inventory(new_revision)
 
2142
 
 
2143
    def _get_check_refs(self):
 
2144
        """Return the references needed to perform a check of this tree.
 
2145
        
 
2146
        The default implementation returns no refs, and is only suitable for
 
2147
        trees that have no local caching and can commit on ghosts at any time.
 
2148
 
 
2149
        :seealso: brzlib.check for details about check_refs.
 
2150
        """
 
2151
        return []
 
2152
 
 
2153
    @needs_read_lock
 
2154
    def _check(self, references):
 
2155
        """Check the tree for consistency.
 
2156
 
 
2157
        :param references: A dict with keys matching the items returned by
 
2158
            self._get_check_refs(), and values from looking those keys up in
 
2159
            the repository.
 
2160
        """
 
2161
        tree_basis = self.basis_tree()
 
2162
        tree_basis.lock_read()
 
2163
        try:
 
2164
            repo_basis = references[('trees', self.last_revision())]
 
2165
            if len(list(repo_basis.iter_changes(tree_basis))) > 0:
 
2166
                raise errors.BzrCheckError(
 
2167
                    "Mismatched basis inventory content.")
 
2168
            self._validate()
 
2169
        finally:
 
2170
            tree_basis.unlock()
 
2171
 
 
2172
    @needs_read_lock
 
2173
    def check_state(self):
 
2174
        """Check that the working state is/isn't valid."""
 
2175
        check_refs = self._get_check_refs()
 
2176
        refs = {}
 
2177
        for ref in check_refs:
 
2178
            kind, value = ref
 
2179
            if kind == 'trees':
 
2180
                refs[ref] = self.branch.repository.revision_tree(value)
 
2181
        self._check(refs)
 
2182
 
 
2183
    @needs_tree_write_lock
 
2184
    def reset_state(self, revision_ids=None):
 
2185
        """Reset the state of the working tree.
 
2186
 
 
2187
        This does a hard-reset to a last-known-good state. This is a way to
 
2188
        fix if something got corrupted (like the .bzr/checkout/dirstate file)
 
2189
        """
 
2190
        if revision_ids is None:
 
2191
            revision_ids = self.get_parent_ids()
 
2192
        if not revision_ids:
 
2193
            rt = self.branch.repository.revision_tree(
 
2194
                _mod_revision.NULL_REVISION)
 
2195
        else:
 
2196
            rt = self.branch.repository.revision_tree(revision_ids[0])
 
2197
        self._write_inventory(rt.root_inventory)
 
2198
        self.set_parent_ids(revision_ids)
 
2199
 
 
2200
    def flush(self):
 
2201
        """Write the in memory inventory to disk."""
 
2202
        # TODO: Maybe this should only write on dirty ?
 
2203
        if self._control_files._lock_mode != 'w':
 
2204
            raise errors.NotWriteLocked(self)
 
2205
        sio = StringIO()
 
2206
        self._serialize(self._inventory, sio)
 
2207
        sio.seek(0)
 
2208
        self._transport.put_file('inventory', sio,
 
2209
            mode=self.bzrdir._get_file_mode())
 
2210
        self._inventory_is_modified = False
 
2211
 
 
2212
    def get_file_mtime(self, file_id, path=None):
 
2213
        """See Tree.get_file_mtime."""
 
2214
        if not path:
 
2215
            path = self.id2path(file_id)
 
2216
        try:
 
2217
            return os.lstat(self.abspath(path)).st_mtime
 
2218
        except OSError, e:
 
2219
            if e.errno == errno.ENOENT:
 
2220
                raise errors.FileTimestampUnavailable(path)
 
2221
            raise
 
2222
 
 
2223
    def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
 
2224
        inv, file_id = self._path2inv_file_id(path)
 
2225
        if file_id is None:
 
2226
            # For unversioned files on win32, we just assume they are not
 
2227
            # executable
 
2228
            return False
 
2229
        return inv[file_id].executable
 
2230
 
 
2231
    def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
 
2232
        mode = stat_result.st_mode
 
2233
        return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
2234
 
 
2235
    def is_executable(self, file_id, path=None):
 
2236
        if not self._supports_executable():
 
2237
            inv, inv_file_id = self._unpack_file_id(file_id)
 
2238
            return inv[inv_file_id].executable
 
2239
        else:
 
2240
            if not path:
 
2241
                path = self.id2path(file_id)
 
2242
            mode = os.lstat(self.abspath(path)).st_mode
 
2243
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
2244
 
 
2245
    def _is_executable_from_path_and_stat(self, path, stat_result):
 
2246
        if not self._supports_executable():
 
2247
            return self._is_executable_from_path_and_stat_from_basis(path, stat_result)
 
2248
        else:
 
2249
            return self._is_executable_from_path_and_stat_from_stat(path, stat_result)
 
2250
 
 
2251
    @needs_tree_write_lock
 
2252
    def _add(self, files, ids, kinds):
 
2253
        """See MutableTree._add."""
 
2254
        # TODO: Re-adding a file that is removed in the working copy
 
2255
        # should probably put it back with the previous ID.
 
2256
        # the read and write working inventory should not occur in this
 
2257
        # function - they should be part of lock_write and unlock.
 
2258
        # FIXME: nested trees
 
2259
        inv = self.root_inventory
 
2260
        for f, file_id, kind in zip(files, ids, kinds):
 
2261
            if file_id is None:
 
2262
                inv.add_path(f, kind=kind)
 
2263
            else:
 
2264
                inv.add_path(f, kind=kind, file_id=file_id)
 
2265
            self._inventory_is_modified = True
 
2266
 
 
2267
    def revision_tree(self, revision_id):
 
2268
        """See WorkingTree.revision_id."""
 
2269
        if revision_id == self.last_revision():
 
2270
            try:
 
2271
                xml = self.read_basis_inventory()
 
2272
            except errors.NoSuchFile:
 
2273
                pass
 
2274
            else:
 
2275
                try:
 
2276
                    inv = xml7.serializer_v7.read_inventory_from_string(xml)
 
2277
                    # dont use the repository revision_tree api because we want
 
2278
                    # to supply the inventory.
 
2279
                    if inv.revision_id == revision_id:
 
2280
                        return revisiontree.InventoryRevisionTree(
 
2281
                            self.branch.repository, inv, revision_id)
 
2282
                except errors.BadInventoryFormat:
 
2283
                    pass
 
2284
        # raise if there was no inventory, or if we read the wrong inventory.
 
2285
        raise errors.NoSuchRevisionInTree(self, revision_id)
 
2286
 
 
2287
    @needs_read_lock
 
2288
    def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
 
2289
        """See Tree.annotate_iter
 
2290
 
 
2291
        This implementation will use the basis tree implementation if possible.
 
2292
        Lines not in the basis are attributed to CURRENT_REVISION
 
2293
 
 
2294
        If there are pending merges, lines added by those merges will be
 
2295
        incorrectly attributed to CURRENT_REVISION (but after committing, the
 
2296
        attribution will be correct).
 
2297
        """
 
2298
        maybe_file_parent_keys = []
 
2299
        for parent_id in self.get_parent_ids():
 
2300
            try:
 
2301
                parent_tree = self.revision_tree(parent_id)
 
2302
            except errors.NoSuchRevisionInTree:
 
2303
                parent_tree = self.branch.repository.revision_tree(parent_id)
 
2304
            parent_tree.lock_read()
 
2305
            try:
 
2306
                try:
 
2307
                    kind = parent_tree.kind(file_id)
 
2308
                except errors.NoSuchId:
 
2309
                    continue
 
2310
                if kind != 'file':
 
2311
                    # Note: this is slightly unnecessary, because symlinks and
 
2312
                    # directories have a "text" which is the empty text, and we
 
2313
                    # know that won't mess up annotations. But it seems cleaner
 
2314
                    continue
 
2315
                parent_text_key = (
 
2316
                    file_id, parent_tree.get_file_revision(file_id))
 
2317
                if parent_text_key not in maybe_file_parent_keys:
 
2318
                    maybe_file_parent_keys.append(parent_text_key)
 
2319
            finally:
 
2320
                parent_tree.unlock()
 
2321
        graph = _mod_graph.Graph(self.branch.repository.texts)
 
2322
        heads = graph.heads(maybe_file_parent_keys)
 
2323
        file_parent_keys = []
 
2324
        for key in maybe_file_parent_keys:
 
2325
            if key in heads:
 
2326
                file_parent_keys.append(key)
 
2327
 
 
2328
        # Now we have the parents of this content
 
2329
        annotator = self.branch.repository.texts.get_annotator()
 
2330
        text = self.get_file_text(file_id)
 
2331
        this_key =(file_id, default_revision)
 
2332
        annotator.add_special_text(this_key, file_parent_keys, text)
 
2333
        annotations = [(key[-1], line)
 
2334
                       for key, line in annotator.annotate_flat(this_key)]
 
2335
        return annotations
 
2336
 
 
2337
    def _put_rio(self, filename, stanzas, header):
 
2338
        self._must_be_locked()
 
2339
        my_file = _mod_rio.rio_file(stanzas, header)
 
2340
        self._transport.put_file(filename, my_file,
 
2341
            mode=self.bzrdir._get_file_mode())
 
2342
 
 
2343
    @needs_tree_write_lock
 
2344
    def set_merge_modified(self, modified_hashes):
 
2345
        def iter_stanzas():
 
2346
            for file_id, hash in modified_hashes.iteritems():
 
2347
                yield _mod_rio.Stanza(file_id=file_id.decode('utf8'),
 
2348
                    hash=hash)
 
2349
        self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
 
2350
 
 
2351
    @needs_read_lock
 
2352
    def merge_modified(self):
 
2353
        """Return a dictionary of files modified by a merge.
 
2354
 
 
2355
        The list is initialized by WorkingTree.set_merge_modified, which is
 
2356
        typically called after we make some automatic updates to the tree
 
2357
        because of a merge.
 
2358
 
 
2359
        This returns a map of file_id->sha1, containing only files which are
 
2360
        still in the working inventory and have that text hash.
 
2361
        """
 
2362
        try:
 
2363
            hashfile = self._transport.get('merge-hashes')
 
2364
        except errors.NoSuchFile:
 
2365
            return {}
 
2366
        try:
 
2367
            merge_hashes = {}
 
2368
            try:
 
2369
                if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
 
2370
                    raise errors.MergeModifiedFormatError()
 
2371
            except StopIteration:
 
2372
                raise errors.MergeModifiedFormatError()
 
2373
            for s in _mod_rio.RioReader(hashfile):
 
2374
                # RioReader reads in Unicode, so convert file_ids back to utf8
 
2375
                file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
 
2376
                if not self.has_id(file_id):
 
2377
                    continue
 
2378
                text_hash = s.get("hash")
 
2379
                if text_hash == self.get_file_sha1(file_id):
 
2380
                    merge_hashes[file_id] = text_hash
 
2381
            return merge_hashes
 
2382
        finally:
 
2383
            hashfile.close()
 
2384
 
 
2385
    @needs_write_lock
 
2386
    def subsume(self, other_tree):
 
2387
        def add_children(inventory, entry):
 
2388
            for child_entry in entry.children.values():
 
2389
                inventory._byid[child_entry.file_id] = child_entry
 
2390
                if child_entry.kind == 'directory':
 
2391
                    add_children(inventory, child_entry)
 
2392
        if other_tree.get_root_id() == self.get_root_id():
 
2393
            raise errors.BadSubsumeSource(self, other_tree,
 
2394
                                          'Trees have the same root')
 
2395
        try:
 
2396
            other_tree_path = self.relpath(other_tree.basedir)
 
2397
        except errors.PathNotChild:
 
2398
            raise errors.BadSubsumeSource(self, other_tree,
 
2399
                'Tree is not contained by the other')
 
2400
        new_root_parent = self.path2id(osutils.dirname(other_tree_path))
 
2401
        if new_root_parent is None:
 
2402
            raise errors.BadSubsumeSource(self, other_tree,
 
2403
                'Parent directory is not versioned.')
 
2404
        # We need to ensure that the result of a fetch will have a
 
2405
        # versionedfile for the other_tree root, and only fetching into
 
2406
        # RepositoryKnit2 guarantees that.
 
2407
        if not self.branch.repository.supports_rich_root():
 
2408
            raise errors.SubsumeTargetNeedsUpgrade(other_tree)
 
2409
        other_tree.lock_tree_write()
 
2410
        try:
 
2411
            new_parents = other_tree.get_parent_ids()
 
2412
            other_root = other_tree.root_inventory.root
 
2413
            other_root.parent_id = new_root_parent
 
2414
            other_root.name = osutils.basename(other_tree_path)
 
2415
            self.root_inventory.add(other_root)
 
2416
            add_children(self.root_inventory, other_root)
 
2417
            self._write_inventory(self.root_inventory)
 
2418
            # normally we don't want to fetch whole repositories, but i think
 
2419
            # here we really do want to consolidate the whole thing.
 
2420
            for parent_id in other_tree.get_parent_ids():
 
2421
                self.branch.fetch(other_tree.branch, parent_id)
 
2422
                self.add_parent_tree_id(parent_id)
 
2423
        finally:
 
2424
            other_tree.unlock()
 
2425
        other_tree.bzrdir.retire_bzrdir()
 
2426
 
 
2427
    @needs_tree_write_lock
 
2428
    def extract(self, file_id, format=None):
 
2429
        """Extract a subtree from this tree.
 
2430
 
 
2431
        A new branch will be created, relative to the path for this tree.
 
2432
        """
 
2433
        self.flush()
 
2434
        def mkdirs(path):
 
2435
            segments = osutils.splitpath(path)
 
2436
            transport = self.branch.bzrdir.root_transport
 
2437
            for name in segments:
 
2438
                transport = transport.clone(name)
 
2439
                transport.ensure_base()
 
2440
            return transport
 
2441
 
 
2442
        sub_path = self.id2path(file_id)
 
2443
        branch_transport = mkdirs(sub_path)
 
2444
        if format is None:
 
2445
            format = self.bzrdir.cloning_metadir()
 
2446
        branch_transport.ensure_base()
 
2447
        branch_bzrdir = format.initialize_on_transport(branch_transport)
 
2448
        try:
 
2449
            repo = branch_bzrdir.find_repository()
 
2450
        except errors.NoRepositoryPresent:
 
2451
            repo = branch_bzrdir.create_repository()
 
2452
        if not repo.supports_rich_root():
 
2453
            raise errors.RootNotRich()
 
2454
        new_branch = branch_bzrdir.create_branch()
 
2455
        new_branch.pull(self.branch)
 
2456
        for parent_id in self.get_parent_ids():
 
2457
            new_branch.fetch(self.branch, parent_id)
 
2458
        tree_transport = self.bzrdir.root_transport.clone(sub_path)
 
2459
        if tree_transport.base != branch_transport.base:
 
2460
            tree_bzrdir = format.initialize_on_transport(tree_transport)
 
2461
            tree_bzrdir.set_branch_reference(new_branch)
 
2462
        else:
 
2463
            tree_bzrdir = branch_bzrdir
 
2464
        wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
 
2465
        wt.set_parent_ids(self.get_parent_ids())
 
2466
        # FIXME: Support nested trees
 
2467
        my_inv = self.root_inventory
 
2468
        child_inv = inventory.Inventory(root_id=None)
 
2469
        new_root = my_inv[file_id]
 
2470
        my_inv.remove_recursive_id(file_id)
 
2471
        new_root.parent_id = None
 
2472
        child_inv.add(new_root)
 
2473
        self._write_inventory(my_inv)
 
2474
        wt._write_inventory(child_inv)
 
2475
        return wt
 
2476
 
 
2477
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
2478
        """List all files as (path, class, kind, id, entry).
 
2479
 
 
2480
        Lists, but does not descend into unversioned directories.
 
2481
        This does not include files that have been deleted in this
 
2482
        tree. Skips the control directory.
 
2483
 
 
2484
        :param include_root: if True, return an entry for the root
 
2485
        :param from_dir: start from this directory or None for the root
 
2486
        :param recursive: whether to recurse into subdirectories or not
 
2487
        """
 
2488
        # list_files is an iterator, so @needs_read_lock doesn't work properly
 
2489
        # with it. So callers should be careful to always read_lock the tree.
 
2490
        if not self.is_locked():
 
2491
            raise errors.ObjectNotLocked(self)
 
2492
 
 
2493
        if from_dir is None and include_root is True:
 
2494
            yield ('', 'V', 'directory', self.get_root_id(), self.root_inventory.root)
 
2495
        # Convert these into local objects to save lookup times
 
2496
        pathjoin = osutils.pathjoin
 
2497
        file_kind = self._kind
 
2498
 
 
2499
        # transport.base ends in a slash, we want the piece
 
2500
        # between the last two slashes
 
2501
        transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
 
2502
 
 
2503
        fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
 
2504
 
 
2505
        # directory file_id, relative path, absolute path, reverse sorted children
 
2506
        if from_dir is not None:
 
2507
            inv, from_dir_id = self._path2inv_file_id(from_dir)
 
2508
            if from_dir_id is None:
 
2509
                # Directory not versioned
 
2510
                return
 
2511
            from_dir_abspath = pathjoin(self.basedir, from_dir)
 
2512
        else:
 
2513
            inv = self.root_inventory
 
2514
            from_dir_id = inv.root.file_id
 
2515
            from_dir_abspath = self.basedir
 
2516
        children = os.listdir(from_dir_abspath)
 
2517
        children.sort()
 
2518
        # jam 20060527 The kernel sized tree seems equivalent whether we
 
2519
        # use a deque and popleft to keep them sorted, or if we use a plain
 
2520
        # list and just reverse() them.
 
2521
        children = collections.deque(children)
 
2522
        stack = [(from_dir_id, u'', from_dir_abspath, children)]
 
2523
        while stack:
 
2524
            from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
 
2525
 
 
2526
            while children:
 
2527
                f = children.popleft()
 
2528
                ## TODO: If we find a subdirectory with its own .bzr
 
2529
                ## directory, then that is a separate tree and we
 
2530
                ## should exclude it.
 
2531
 
 
2532
                # the bzrdir for this tree
 
2533
                if transport_base_dir == f:
 
2534
                    continue
 
2535
 
 
2536
                # we know that from_dir_relpath and from_dir_abspath never end in a slash
 
2537
                # and 'f' doesn't begin with one, we can do a string op, rather
 
2538
                # than the checks of pathjoin(), all relative paths will have an extra slash
 
2539
                # at the beginning
 
2540
                fp = from_dir_relpath + '/' + f
 
2541
 
 
2542
                # absolute path
 
2543
                fap = from_dir_abspath + '/' + f
 
2544
 
 
2545
                dir_ie = inv[from_dir_id]
 
2546
                if dir_ie.kind == 'directory':
 
2547
                    f_ie = dir_ie.children.get(f)
 
2548
                else:
 
2549
                    f_ie = None
 
2550
                if f_ie:
 
2551
                    c = 'V'
 
2552
                elif self.is_ignored(fp[1:]):
 
2553
                    c = 'I'
 
2554
                else:
 
2555
                    # we may not have found this file, because of a unicode
 
2556
                    # issue, or because the directory was actually a symlink.
 
2557
                    f_norm, can_access = osutils.normalized_filename(f)
 
2558
                    if f == f_norm or not can_access:
 
2559
                        # No change, so treat this file normally
 
2560
                        c = '?'
 
2561
                    else:
 
2562
                        # this file can be accessed by a normalized path
 
2563
                        # check again if it is versioned
 
2564
                        # these lines are repeated here for performance
 
2565
                        f = f_norm
 
2566
                        fp = from_dir_relpath + '/' + f
 
2567
                        fap = from_dir_abspath + '/' + f
 
2568
                        f_ie = inv.get_child(from_dir_id, f)
 
2569
                        if f_ie:
 
2570
                            c = 'V'
 
2571
                        elif self.is_ignored(fp[1:]):
 
2572
                            c = 'I'
 
2573
                        else:
 
2574
                            c = '?'
 
2575
 
 
2576
                fk = file_kind(fap)
 
2577
 
 
2578
                # make a last minute entry
 
2579
                if f_ie:
 
2580
                    yield fp[1:], c, fk, f_ie.file_id, f_ie
 
2581
                else:
 
2582
                    try:
 
2583
                        yield fp[1:], c, fk, None, fk_entries[fk]()
 
2584
                    except KeyError:
 
2585
                        yield fp[1:], c, fk, None, TreeEntry()
 
2586
                    continue
 
2587
 
 
2588
                if fk != 'directory':
 
2589
                    continue
 
2590
 
 
2591
                # But do this child first if recursing down
 
2592
                if recursive:
 
2593
                    new_children = os.listdir(fap)
 
2594
                    new_children.sort()
 
2595
                    new_children = collections.deque(new_children)
 
2596
                    stack.append((f_ie.file_id, fp, fap, new_children))
 
2597
                    # Break out of inner loop,
 
2598
                    # so that we start outer loop with child
 
2599
                    break
 
2600
            else:
 
2601
                # if we finished all children, pop it off the stack
 
2602
                stack.pop()
 
2603
 
 
2604
    @needs_tree_write_lock
 
2605
    def move(self, from_paths, to_dir=None, after=False):
 
2606
        """Rename files.
 
2607
 
 
2608
        to_dir must exist in the inventory.
 
2609
 
 
2610
        If to_dir exists and is a directory, the files are moved into
 
2611
        it, keeping their old names.
 
2612
 
 
2613
        Note that to_dir is only the last component of the new name;
 
2614
        this doesn't change the directory.
 
2615
 
 
2616
        For each entry in from_paths the move mode will be determined
 
2617
        independently.
 
2618
 
 
2619
        The first mode moves the file in the filesystem and updates the
 
2620
        inventory. The second mode only updates the inventory without
 
2621
        touching the file on the filesystem.
 
2622
 
 
2623
        move uses the second mode if 'after == True' and the target is
 
2624
        either not versioned or newly added, and present in the working tree.
 
2625
 
 
2626
        move uses the second mode if 'after == False' and the source is
 
2627
        versioned but no longer in the working tree, and the target is not
 
2628
        versioned but present in the working tree.
 
2629
 
 
2630
        move uses the first mode if 'after == False' and the source is
 
2631
        versioned and present in the working tree, and the target is not
 
2632
        versioned and not present in the working tree.
 
2633
 
 
2634
        Everything else results in an error.
 
2635
 
 
2636
        This returns a list of (from_path, to_path) pairs for each
 
2637
        entry that is moved.
 
2638
        """
 
2639
        rename_entries = []
 
2640
        rename_tuples = []
 
2641
 
 
2642
        invs_to_write = set()
 
2643
 
 
2644
        # check for deprecated use of signature
 
2645
        if to_dir is None:
 
2646
            raise TypeError('You must supply a target directory')
 
2647
        # check destination directory
 
2648
        if isinstance(from_paths, basestring):
 
2649
            raise ValueError()
 
2650
        to_abs = self.abspath(to_dir)
 
2651
        if not isdir(to_abs):
 
2652
            raise errors.BzrMoveFailedError('',to_dir,
 
2653
                errors.NotADirectory(to_abs))
 
2654
        if not self.has_filename(to_dir):
 
2655
            raise errors.BzrMoveFailedError('',to_dir,
 
2656
                errors.NotInWorkingDirectory(to_dir))
 
2657
        to_inv, to_dir_id = self._path2inv_file_id(to_dir)
 
2658
        if to_dir_id is None:
 
2659
            raise errors.BzrMoveFailedError('',to_dir,
 
2660
                errors.NotVersionedError(path=to_dir))
 
2661
 
 
2662
        to_dir_ie = to_inv[to_dir_id]
 
2663
        if to_dir_ie.kind != 'directory':
 
2664
            raise errors.BzrMoveFailedError('',to_dir,
 
2665
                errors.NotADirectory(to_abs))
 
2666
 
 
2667
        # create rename entries and tuples
 
2668
        for from_rel in from_paths:
 
2669
            from_tail = splitpath(from_rel)[-1]
 
2670
            from_inv, from_id = self._path2inv_file_id(from_rel)
 
2671
            if from_id is None:
 
2672
                raise errors.BzrMoveFailedError(from_rel,to_dir,
 
2673
                    errors.NotVersionedError(path=from_rel))
 
2674
 
 
2675
            from_entry = from_inv[from_id]
 
2676
            from_parent_id = from_entry.parent_id
 
2677
            to_rel = pathjoin(to_dir, from_tail)
 
2678
            rename_entry = InventoryWorkingTree._RenameEntry(
 
2679
                from_rel=from_rel,
 
2680
                from_id=from_id,
 
2681
                from_tail=from_tail,
 
2682
                from_parent_id=from_parent_id,
 
2683
                to_rel=to_rel, to_tail=from_tail,
 
2684
                to_parent_id=to_dir_id)
 
2685
            rename_entries.append(rename_entry)
 
2686
            rename_tuples.append((from_rel, to_rel))
 
2687
 
 
2688
        # determine which move mode to use. checks also for movability
 
2689
        rename_entries = self._determine_mv_mode(rename_entries, after)
 
2690
 
 
2691
        original_modified = self._inventory_is_modified
 
2692
        try:
 
2693
            if len(from_paths):
 
2694
                self._inventory_is_modified = True
 
2695
            self._move(rename_entries)
 
2696
        except:
 
2697
            # restore the inventory on error
 
2698
            self._inventory_is_modified = original_modified
 
2699
            raise
 
2700
        #FIXME: Should potentially also write the from_invs
 
2701
        self._write_inventory(to_inv)
 
2702
        return rename_tuples
 
2703
 
 
2704
    @needs_tree_write_lock
 
2705
    def rename_one(self, from_rel, to_rel, after=False):
 
2706
        """Rename one file.
 
2707
 
 
2708
        This can change the directory or the filename or both.
 
2709
 
 
2710
        rename_one has several 'modes' to work. First, it can rename a physical
 
2711
        file and change the file_id. That is the normal mode. Second, it can
 
2712
        only change the file_id without touching any physical file.
 
2713
 
 
2714
        rename_one uses the second mode if 'after == True' and 'to_rel' is not
 
2715
        versioned but present in the working tree.
 
2716
 
 
2717
        rename_one uses the second mode if 'after == False' and 'from_rel' is
 
2718
        versioned but no longer in the working tree, and 'to_rel' is not
 
2719
        versioned but present in the working tree.
 
2720
 
 
2721
        rename_one uses the first mode if 'after == False' and 'from_rel' is
 
2722
        versioned and present in the working tree, and 'to_rel' is not
 
2723
        versioned and not present in the working tree.
 
2724
 
 
2725
        Everything else results in an error.
 
2726
        """
 
2727
        rename_entries = []
 
2728
 
 
2729
        # create rename entries and tuples
 
2730
        from_tail = splitpath(from_rel)[-1]
 
2731
        from_inv, from_id = self._path2inv_file_id(from_rel)
 
2732
        if from_id is None:
 
2733
            # if file is missing in the inventory maybe it's in the basis_tree
 
2734
            basis_tree = self.branch.basis_tree()
 
2735
            from_id = basis_tree.path2id(from_rel)
 
2736
            if from_id is None:
 
2737
                raise errors.BzrRenameFailedError(from_rel,to_rel,
 
2738
                    errors.NotVersionedError(path=from_rel))
 
2739
            # put entry back in the inventory so we can rename it
 
2740
            from_entry = basis_tree.root_inventory[from_id].copy()
 
2741
            from_inv.add(from_entry)
 
2742
        else:
 
2743
            from_inv, from_inv_id = self._unpack_file_id(from_id)
 
2744
            from_entry = from_inv[from_inv_id]
 
2745
        from_parent_id = from_entry.parent_id
 
2746
        to_dir, to_tail = os.path.split(to_rel)
 
2747
        to_inv, to_dir_id = self._path2inv_file_id(to_dir)
 
2748
        rename_entry = InventoryWorkingTree._RenameEntry(from_rel=from_rel,
 
2749
                                     from_id=from_id,
 
2750
                                     from_tail=from_tail,
 
2751
                                     from_parent_id=from_parent_id,
 
2752
                                     to_rel=to_rel, to_tail=to_tail,
 
2753
                                     to_parent_id=to_dir_id)
 
2754
        rename_entries.append(rename_entry)
 
2755
 
 
2756
        # determine which move mode to use. checks also for movability
 
2757
        rename_entries = self._determine_mv_mode(rename_entries, after)
 
2758
 
 
2759
        # check if the target changed directory and if the target directory is
 
2760
        # versioned
 
2761
        if to_dir_id is None:
 
2762
            raise errors.BzrMoveFailedError(from_rel,to_rel,
 
2763
                errors.NotVersionedError(path=to_dir))
 
2764
 
 
2765
        # all checks done. now we can continue with our actual work
 
2766
        mutter('rename_one:\n'
 
2767
               '  from_id   {%s}\n'
 
2768
               '  from_rel: %r\n'
 
2769
               '  to_rel:   %r\n'
 
2770
               '  to_dir    %r\n'
 
2771
               '  to_dir_id {%s}\n',
 
2772
               from_id, from_rel, to_rel, to_dir, to_dir_id)
 
2773
 
 
2774
        self._move(rename_entries)
 
2775
        self._write_inventory(to_inv)
 
2776
 
 
2777
    class _RenameEntry(object):
 
2778
        def __init__(self, from_rel, from_id, from_tail, from_parent_id,
 
2779
                     to_rel, to_tail, to_parent_id, only_change_inv=False,
 
2780
                     change_id=False):
 
2781
            self.from_rel = from_rel
 
2782
            self.from_id = from_id
 
2783
            self.from_tail = from_tail
 
2784
            self.from_parent_id = from_parent_id
 
2785
            self.to_rel = to_rel
 
2786
            self.to_tail = to_tail
 
2787
            self.to_parent_id = to_parent_id
 
2788
            self.change_id = change_id
 
2789
            self.only_change_inv = only_change_inv
 
2790
 
 
2791
    def _determine_mv_mode(self, rename_entries, after=False):
 
2792
        """Determines for each from-to pair if both inventory and working tree
 
2793
        or only the inventory has to be changed.
 
2794
 
 
2795
        Also does basic plausability tests.
 
2796
        """
 
2797
        # FIXME: Handling of nested trees
 
2798
        inv = self.root_inventory
 
2799
 
 
2800
        for rename_entry in rename_entries:
 
2801
            # store to local variables for easier reference
 
2802
            from_rel = rename_entry.from_rel
 
2803
            from_id = rename_entry.from_id
 
2804
            to_rel = rename_entry.to_rel
 
2805
            to_id = inv.path2id(to_rel)
 
2806
            only_change_inv = False
 
2807
            change_id = False
 
2808
 
 
2809
            # check the inventory for source and destination
 
2810
            if from_id is None:
 
2811
                raise errors.BzrMoveFailedError(from_rel,to_rel,
 
2812
                    errors.NotVersionedError(path=from_rel))
 
2813
            if to_id is not None:
 
2814
                allowed = False
 
2815
                # allow it with --after but only if dest is newly added
 
2816
                if after:
 
2817
                    basis = self.basis_tree()
 
2818
                    basis.lock_read()
 
2819
                    try:
 
2820
                        if not basis.has_id(to_id):
 
2821
                            rename_entry.change_id = True
 
2822
                            allowed = True
 
2823
                    finally:
 
2824
                        basis.unlock()
 
2825
                if not allowed:
 
2826
                    raise errors.BzrMoveFailedError(from_rel,to_rel,
 
2827
                        errors.AlreadyVersionedError(path=to_rel))
 
2828
 
 
2829
            # try to determine the mode for rename (only change inv or change
 
2830
            # inv and file system)
 
2831
            if after:
 
2832
                if not self.has_filename(to_rel):
 
2833
                    raise errors.BzrMoveFailedError(from_id,to_rel,
 
2834
                        errors.NoSuchFile(path=to_rel,
 
2835
                        extra="New file has not been created yet"))
 
2836
                only_change_inv = True
 
2837
            elif not self.has_filename(from_rel) and self.has_filename(to_rel):
 
2838
                only_change_inv = True
 
2839
            elif self.has_filename(from_rel) and not self.has_filename(to_rel):
 
2840
                only_change_inv = False
 
2841
            elif (not self.case_sensitive
 
2842
                  and from_rel.lower() == to_rel.lower()
 
2843
                  and self.has_filename(from_rel)):
 
2844
                only_change_inv = False
 
2845
            else:
 
2846
                # something is wrong, so lets determine what exactly
 
2847
                if not self.has_filename(from_rel) and \
 
2848
                   not self.has_filename(to_rel):
 
2849
                    raise errors.BzrRenameFailedError(from_rel, to_rel,
 
2850
                        errors.PathsDoNotExist(paths=(from_rel, to_rel)))
 
2851
                else:
 
2852
                    raise errors.RenameFailedFilesExist(from_rel, to_rel)
 
2853
            rename_entry.only_change_inv = only_change_inv
 
2854
        return rename_entries
 
2855
 
 
2856
    def _move(self, rename_entries):
 
2857
        """Moves a list of files.
 
2858
 
 
2859
        Depending on the value of the flag 'only_change_inv', the
 
2860
        file will be moved on the file system or not.
 
2861
        """
 
2862
        moved = []
 
2863
 
 
2864
        for entry in rename_entries:
 
2865
            try:
 
2866
                self._move_entry(entry)
 
2867
            except:
 
2868
                self._rollback_move(moved)
 
2869
                raise
 
2870
            moved.append(entry)
 
2871
 
 
2872
    def _rollback_move(self, moved):
 
2873
        """Try to rollback a previous move in case of an filesystem error."""
 
2874
        for entry in moved:
 
2875
            try:
 
2876
                self._move_entry(WorkingTree._RenameEntry(
 
2877
                    entry.to_rel, entry.from_id,
 
2878
                    entry.to_tail, entry.to_parent_id, entry.from_rel,
 
2879
                    entry.from_tail, entry.from_parent_id,
 
2880
                    entry.only_change_inv))
 
2881
            except errors.BzrMoveFailedError, e:
 
2882
                raise errors.BzrMoveFailedError( '', '', "Rollback failed."
 
2883
                        " The working tree is in an inconsistent state."
 
2884
                        " Please consider doing a 'bzr revert'."
 
2885
                        " Error message is: %s" % e)
 
2886
 
 
2887
    def _move_entry(self, entry):
 
2888
        inv = self.root_inventory
 
2889
        from_rel_abs = self.abspath(entry.from_rel)
 
2890
        to_rel_abs = self.abspath(entry.to_rel)
 
2891
        if from_rel_abs == to_rel_abs:
 
2892
            raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
 
2893
                "Source and target are identical.")
 
2894
 
 
2895
        if not entry.only_change_inv:
 
2896
            try:
 
2897
                osutils.rename(from_rel_abs, to_rel_abs)
 
2898
            except OSError, e:
 
2899
                raise errors.BzrMoveFailedError(entry.from_rel,
 
2900
                    entry.to_rel, e[1])
 
2901
        if entry.change_id:
 
2902
            to_id = inv.path2id(entry.to_rel)
 
2903
            inv.remove_recursive_id(to_id)
 
2904
        inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
 
2905
 
 
2906
    @needs_tree_write_lock
 
2907
    def unversion(self, file_ids):
 
2908
        """Remove the file ids in file_ids from the current versioned set.
 
2909
 
 
2910
        When a file_id is unversioned, all of its children are automatically
 
2911
        unversioned.
 
2912
 
 
2913
        :param file_ids: The file ids to stop versioning.
 
2914
        :raises: NoSuchId if any fileid is not currently versioned.
 
2915
        """
 
2916
        for file_id in file_ids:
 
2917
            if not self._inventory.has_id(file_id):
 
2918
                raise errors.NoSuchId(self, file_id)
 
2919
        for file_id in file_ids:
 
2920
            if self._inventory.has_id(file_id):
 
2921
                self._inventory.remove_recursive_id(file_id)
 
2922
        if len(file_ids):
 
2923
            # in the future this should just set a dirty bit to wait for the
 
2924
            # final unlock. However, until all methods of workingtree start
 
2925
            # with the current in -memory inventory rather than triggering
 
2926
            # a read, it is more complex - we need to teach read_inventory
 
2927
            # to know when to read, and when to not read first... and possibly
 
2928
            # to save first when the in memory one may be corrupted.
 
2929
            # so for now, we just only write it if it is indeed dirty.
 
2930
            # - RBC 20060907
 
2931
            self._write_inventory(self._inventory)
 
2932
 
 
2933
    def stored_kind(self, file_id):
 
2934
        """See Tree.stored_kind"""
 
2935
        inv, inv_file_id = self._unpack_file_id(file_id)
 
2936
        return inv[inv_file_id].kind
 
2937
 
 
2938
    def extras(self):
 
2939
        """Yield all unversioned files in this WorkingTree.
 
2940
 
 
2941
        If there are any unversioned directories then only the directory is
 
2942
        returned, not all its children.  But if there are unversioned files
 
2943
        under a versioned subdirectory, they are returned.
 
2944
 
 
2945
        Currently returned depth-first, sorted by name within directories.
 
2946
        This is the same order used by 'osutils.walkdirs'.
 
2947
        """
 
2948
        ## TODO: Work from given directory downwards
 
2949
        for path, dir_entry in self.iter_entries_by_dir():
 
2950
            if dir_entry.kind != 'directory':
 
2951
                continue
 
2952
            # mutter("search for unknowns in %r", path)
 
2953
            dirabs = self.abspath(path)
 
2954
            if not isdir(dirabs):
 
2955
                # e.g. directory deleted
 
2956
                continue
 
2957
 
 
2958
            fl = []
 
2959
            for subf in os.listdir(dirabs):
 
2960
                if self.bzrdir.is_control_filename(subf):
 
2961
                    continue
 
2962
                if subf not in dir_entry.children:
 
2963
                    try:
 
2964
                        (subf_norm,
 
2965
                         can_access) = osutils.normalized_filename(subf)
 
2966
                    except UnicodeDecodeError:
 
2967
                        path_os_enc = path.encode(osutils._fs_enc)
 
2968
                        relpath = path_os_enc + '/' + subf
 
2969
                        raise errors.BadFilenameEncoding(relpath,
 
2970
                                                         osutils._fs_enc)
 
2971
                    if subf_norm != subf and can_access:
 
2972
                        if subf_norm not in dir_entry.children:
 
2973
                            fl.append(subf_norm)
 
2974
                    else:
 
2975
                        fl.append(subf)
 
2976
 
 
2977
            fl.sort()
 
2978
            for subf in fl:
 
2979
                subp = pathjoin(path, subf)
 
2980
                yield subp
 
2981
 
 
2982
    def _walkdirs(self, prefix=""):
 
2983
        """Walk the directories of this tree.
 
2984
 
 
2985
        :param prefix: is used as the directrory to start with.
 
2986
        :returns: a generator which yields items in the form::
 
2987
 
 
2988
            ((curren_directory_path, fileid),
 
2989
             [(file1_path, file1_name, file1_kind, None, file1_id,
 
2990
               file1_kind), ... ])
 
2991
        """
 
2992
        _directory = 'directory'
 
2993
        # get the root in the inventory
 
2994
        inv, top_id = self._path2inv_file_id(prefix)
 
2995
        if top_id is None:
 
2996
            pending = []
 
2997
        else:
 
2998
            pending = [(prefix, '', _directory, None, top_id, None)]
 
2999
        while pending:
 
3000
            dirblock = []
 
3001
            currentdir = pending.pop()
 
3002
            # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
 
3003
            top_id = currentdir[4]
 
3004
            if currentdir[0]:
 
3005
                relroot = currentdir[0] + '/'
 
3006
            else:
 
3007
                relroot = ""
 
3008
            # FIXME: stash the node in pending
 
3009
            entry = inv[top_id]
 
3010
            if entry.kind == 'directory':
 
3011
                for name, child in entry.sorted_children():
 
3012
                    dirblock.append((relroot + name, name, child.kind, None,
 
3013
                        child.file_id, child.kind
 
3014
                        ))
 
3015
            yield (currentdir[0], entry.file_id), dirblock
 
3016
            # push the user specified dirs from dirblock
 
3017
            for dir in reversed(dirblock):
 
3018
                if dir[2] == _directory:
 
3019
                    pending.append(dir)
 
3020
 
 
3021
    @needs_write_lock
 
3022
    def update_feature_flags(self, updated_flags):
 
3023
        """Update the feature flags for this branch.
 
3024
 
 
3025
        :param updated_flags: Dictionary mapping feature names to necessities
 
3026
            A necessity can be None to indicate the feature should be removed
 
3027
        """
 
3028
        self._format._update_feature_flags(updated_flags)
 
3029
        self.control_transport.put_bytes('format', self._format.as_string())
 
3030
 
 
3031
 
 
3032
class WorkingTreeFormatRegistry(controldir.ControlComponentFormatRegistry):
 
3033
    """Registry for working tree formats."""
 
3034
 
 
3035
    def __init__(self, other_registry=None):
 
3036
        super(WorkingTreeFormatRegistry, self).__init__(other_registry)
 
3037
        self._default_format = None
 
3038
        self._default_format_key = None
 
3039
 
 
3040
    def get_default(self):
 
3041
        """Return the current default format."""
 
3042
        if (self._default_format_key is not None and
 
3043
            self._default_format is None):
 
3044
            self._default_format = self.get(self._default_format_key)
 
3045
        return self._default_format
 
3046
 
 
3047
    def set_default(self, format):
 
3048
        """Set the default format."""
 
3049
        self._default_format = format
 
3050
        self._default_format_key = None
 
3051
 
 
3052
    def set_default_key(self, format_string):
 
3053
        """Set the default format by its format string."""
 
3054
        self._default_format_key = format_string
 
3055
        self._default_format = None
 
3056
 
 
3057
 
 
3058
format_registry = WorkingTreeFormatRegistry()
 
3059
 
 
3060
 
 
3061
class WorkingTreeFormat(controldir.ControlComponentFormat):
2771
3062
    """An encapsulation of the initialization and open routines for a format.
2772
3063
 
2773
3064
    Formats provide three things:
2785
3076
    object will be created every time regardless.
2786
3077
    """
2787
3078
 
2788
 
    _default_format = None
2789
 
    """The default format used for new trees."""
2790
 
 
2791
 
    _formats = {}
2792
 
    """The known formats."""
2793
 
 
2794
3079
    requires_rich_root = False
2795
3080
 
2796
3081
    upgrade_recommended = False
2797
3082
 
2798
 
    @classmethod
2799
 
    def find_format(klass, a_bzrdir):
2800
 
        """Return the format for the working tree object in a_bzrdir."""
2801
 
        try:
2802
 
            transport = a_bzrdir.get_workingtree_transport(None)
2803
 
            format_string = transport.get_bytes("format")
2804
 
            return klass._formats[format_string]
2805
 
        except errors.NoSuchFile:
2806
 
            raise errors.NoWorkingTree(base=transport.base)
2807
 
        except KeyError:
2808
 
            raise errors.UnknownFormatError(format=format_string,
2809
 
                                            kind="working tree")
 
3083
    requires_normalized_unicode_filenames = False
 
3084
 
 
3085
    case_sensitive_filename = "FoRMaT"
 
3086
 
 
3087
    missing_parent_conflicts = False
 
3088
    """If this format supports missing parent conflicts."""
 
3089
 
 
3090
    supports_versioned_directories = None
 
3091
 
 
3092
    def initialize(self, controldir, revision_id=None, from_branch=None,
 
3093
                   accelerator_tree=None, hardlink=False):
 
3094
        """Initialize a new working tree in controldir.
 
3095
 
 
3096
        :param controldir: ControlDir to initialize the working tree in.
 
3097
        :param revision_id: allows creating a working tree at a different
 
3098
            revision than the branch is at.
 
3099
        :param from_branch: Branch to checkout
 
3100
        :param accelerator_tree: A tree which can be used for retrieving file
 
3101
            contents more quickly than the revision tree, i.e. a workingtree.
 
3102
            The revision tree will be used for cases where accelerator_tree's
 
3103
            content is different.
 
3104
        :param hardlink: If true, hard-link files from accelerator_tree,
 
3105
            where possible.
 
3106
        """
 
3107
        raise NotImplementedError(self.initialize)
2810
3108
 
2811
3109
    def __eq__(self, other):
2812
3110
        return self.__class__ is other.__class__
2814
3112
    def __ne__(self, other):
2815
3113
        return not (self == other)
2816
3114
 
2817
 
    @classmethod
2818
 
    def get_default_format(klass):
2819
 
        """Return the current default format."""
2820
 
        return klass._default_format
2821
 
 
2822
 
    def get_format_string(self):
2823
 
        """Return the ASCII format string that identifies this format."""
2824
 
        raise NotImplementedError(self.get_format_string)
2825
 
 
2826
3115
    def get_format_description(self):
2827
3116
        """Return the short description for this format."""
2828
3117
        raise NotImplementedError(self.get_format_description)
2844
3133
        """True if this format supports stored views."""
2845
3134
        return False
2846
3135
 
2847
 
    @classmethod
2848
 
    def register_format(klass, format):
2849
 
        klass._formats[format.get_format_string()] = format
2850
 
 
2851
 
    @classmethod
2852
 
    def set_default_format(klass, format):
2853
 
        klass._default_format = format
2854
 
 
2855
 
    @classmethod
2856
 
    def unregister_format(klass, format):
2857
 
        del klass._formats[format.get_format_string()]
2858
 
 
2859
 
 
2860
 
class WorkingTreeFormat2(WorkingTreeFormat):
2861
 
    """The second working tree format.
2862
 
 
2863
 
    This format modified the hash cache from the format 1 hash cache.
2864
 
    """
2865
 
 
2866
 
    upgrade_recommended = True
2867
 
 
2868
 
    def get_format_description(self):
2869
 
        """See WorkingTreeFormat.get_format_description()."""
2870
 
        return "Working tree format 2"
2871
 
 
2872
 
    def _stub_initialize_on_transport(self, transport, file_mode):
2873
 
        """Workaround: create control files for a remote working tree.
2874
 
 
2875
 
        This ensures that it can later be updated and dealt with locally,
2876
 
        since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with
2877
 
        no working tree.  (See bug #43064).
2878
 
        """
2879
 
        sio = StringIO()
2880
 
        inv = inventory.Inventory()
2881
 
        xml5.serializer_v5.write_inventory(inv, sio, working=True)
2882
 
        sio.seek(0)
2883
 
        transport.put_file('inventory', sio, file_mode)
2884
 
        transport.put_bytes('pending-merges', '', file_mode)
2885
 
 
2886
 
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
2887
 
                   accelerator_tree=None, hardlink=False):
2888
 
        """See WorkingTreeFormat.initialize()."""
2889
 
        if not isinstance(a_bzrdir.transport, LocalTransport):
2890
 
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
2891
 
        if from_branch is not None:
2892
 
            branch = from_branch
2893
 
        else:
2894
 
            branch = a_bzrdir.open_branch()
2895
 
        if revision_id is None:
2896
 
            revision_id = _mod_revision.ensure_null(branch.last_revision())
2897
 
        branch.lock_write()
2898
 
        try:
2899
 
            branch.generate_revision_history(revision_id)
2900
 
        finally:
2901
 
            branch.unlock()
2902
 
        inv = inventory.Inventory()
2903
 
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
2904
 
                         branch,
2905
 
                         inv,
2906
 
                         _internal=True,
2907
 
                         _format=self,
2908
 
                         _bzrdir=a_bzrdir)
2909
 
        basis_tree = branch.repository.revision_tree(revision_id)
2910
 
        if basis_tree.inventory.root is not None:
2911
 
            wt.set_root_id(basis_tree.get_root_id())
2912
 
        # set the parent list and cache the basis tree.
2913
 
        if _mod_revision.is_null(revision_id):
2914
 
            parent_trees = []
2915
 
        else:
2916
 
            parent_trees = [(revision_id, basis_tree)]
2917
 
        wt.set_parent_trees(parent_trees)
2918
 
        transform.build_tree(basis_tree, wt)
2919
 
        return wt
2920
 
 
2921
 
    def __init__(self):
2922
 
        super(WorkingTreeFormat2, self).__init__()
2923
 
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
2924
 
 
2925
 
    def open(self, a_bzrdir, _found=False):
2926
 
        """Return the WorkingTree object for a_bzrdir
2927
 
 
2928
 
        _found is a private parameter, do not use it. It is used to indicate
2929
 
               if format probing has already been done.
2930
 
        """
2931
 
        if not _found:
2932
 
            # we are being called directly and must probe.
2933
 
            raise NotImplementedError
2934
 
        if not isinstance(a_bzrdir.transport, LocalTransport):
2935
 
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
2936
 
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
2937
 
                           _internal=True,
2938
 
                           _format=self,
2939
 
                           _bzrdir=a_bzrdir)
2940
 
        return wt
2941
 
 
2942
 
class WorkingTreeFormat3(WorkingTreeFormat):
2943
 
    """The second working tree format updated to record a format marker.
2944
 
 
2945
 
    This format:
2946
 
        - exists within a metadir controlling .bzr
2947
 
        - includes an explicit version marker for the workingtree control
2948
 
          files, separate from the BzrDir format
2949
 
        - modifies the hash cache format
2950
 
        - is new in bzr 0.8
2951
 
        - uses a LockDir to guard access for writes.
2952
 
    """
2953
 
 
2954
 
    upgrade_recommended = True
2955
 
 
2956
 
    def get_format_string(self):
2957
 
        """See WorkingTreeFormat.get_format_string()."""
2958
 
        return "Bazaar-NG Working Tree format 3"
2959
 
 
2960
 
    def get_format_description(self):
2961
 
        """See WorkingTreeFormat.get_format_description()."""
2962
 
        return "Working tree format 3"
2963
 
 
2964
 
    _lock_file_name = 'lock'
2965
 
    _lock_class = LockDir
2966
 
 
2967
 
    _tree_class = WorkingTree3
2968
 
 
2969
 
    def __get_matchingbzrdir(self):
2970
 
        return bzrdir.BzrDirMetaFormat1()
2971
 
 
2972
 
    _matchingbzrdir = property(__get_matchingbzrdir)
2973
 
 
2974
 
    def _open_control_files(self, a_bzrdir):
2975
 
        transport = a_bzrdir.get_workingtree_transport(None)
2976
 
        return LockableFiles(transport, self._lock_file_name,
2977
 
                             self._lock_class)
2978
 
 
2979
 
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
2980
 
                   accelerator_tree=None, hardlink=False):
2981
 
        """See WorkingTreeFormat.initialize().
2982
 
 
2983
 
        :param revision_id: if supplied, create a working tree at a different
2984
 
            revision than the branch is at.
2985
 
        :param accelerator_tree: A tree which can be used for retrieving file
2986
 
            contents more quickly than the revision tree, i.e. a workingtree.
2987
 
            The revision tree will be used for cases where accelerator_tree's
2988
 
            content is different.
2989
 
        :param hardlink: If true, hard-link files from accelerator_tree,
2990
 
            where possible.
2991
 
        """
2992
 
        if not isinstance(a_bzrdir.transport, LocalTransport):
2993
 
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
2994
 
        transport = a_bzrdir.get_workingtree_transport(self)
2995
 
        control_files = self._open_control_files(a_bzrdir)
2996
 
        control_files.create_lock()
2997
 
        control_files.lock_write()
2998
 
        transport.put_bytes('format', self.get_format_string(),
2999
 
            mode=a_bzrdir._get_file_mode())
3000
 
        if from_branch is not None:
3001
 
            branch = from_branch
3002
 
        else:
3003
 
            branch = a_bzrdir.open_branch()
3004
 
        if revision_id is None:
3005
 
            revision_id = _mod_revision.ensure_null(branch.last_revision())
3006
 
        # WorkingTree3 can handle an inventory which has a unique root id.
3007
 
        # as of bzr 0.12. However, bzr 0.11 and earlier fail to handle
3008
 
        # those trees. And because there isn't a format bump inbetween, we
3009
 
        # are maintaining compatibility with older clients.
3010
 
        # inv = Inventory(root_id=gen_root_id())
3011
 
        inv = self._initial_inventory()
3012
 
        wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
3013
 
                         branch,
3014
 
                         inv,
3015
 
                         _internal=True,
3016
 
                         _format=self,
3017
 
                         _bzrdir=a_bzrdir,
3018
 
                         _control_files=control_files)
3019
 
        wt.lock_tree_write()
3020
 
        try:
3021
 
            basis_tree = branch.repository.revision_tree(revision_id)
3022
 
            # only set an explicit root id if there is one to set.
3023
 
            if basis_tree.inventory.root is not None:
3024
 
                wt.set_root_id(basis_tree.get_root_id())
3025
 
            if revision_id == _mod_revision.NULL_REVISION:
3026
 
                wt.set_parent_trees([])
3027
 
            else:
3028
 
                wt.set_parent_trees([(revision_id, basis_tree)])
3029
 
            transform.build_tree(basis_tree, wt)
3030
 
        finally:
3031
 
            # Unlock in this order so that the unlock-triggers-flush in
3032
 
            # WorkingTree is given a chance to fire.
3033
 
            control_files.unlock()
3034
 
            wt.unlock()
3035
 
        return wt
3036
 
 
3037
 
    def _initial_inventory(self):
3038
 
        return inventory.Inventory()
3039
 
 
3040
 
    def __init__(self):
3041
 
        super(WorkingTreeFormat3, self).__init__()
3042
 
 
3043
 
    def open(self, a_bzrdir, _found=False):
3044
 
        """Return the WorkingTree object for a_bzrdir
3045
 
 
3046
 
        _found is a private parameter, do not use it. It is used to indicate
3047
 
               if format probing has already been done.
3048
 
        """
3049
 
        if not _found:
3050
 
            # we are being called directly and must probe.
3051
 
            raise NotImplementedError
3052
 
        if not isinstance(a_bzrdir.transport, LocalTransport):
3053
 
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
3054
 
        wt = self._open(a_bzrdir, self._open_control_files(a_bzrdir))
3055
 
        return wt
3056
 
 
3057
 
    def _open(self, a_bzrdir, control_files):
3058
 
        """Open the tree itself.
3059
 
 
3060
 
        :param a_bzrdir: the dir for the tree.
3061
 
        :param control_files: the control files for the tree.
3062
 
        """
3063
 
        return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
3064
 
                                _internal=True,
3065
 
                                _format=self,
3066
 
                                _bzrdir=a_bzrdir,
3067
 
                                _control_files=control_files)
3068
 
 
3069
 
    def __str__(self):
3070
 
        return self.get_format_string()
3071
 
 
3072
 
 
3073
 
__default_format = WorkingTreeFormat6()
3074
 
WorkingTreeFormat.register_format(__default_format)
3075
 
WorkingTreeFormat.register_format(WorkingTreeFormat5())
3076
 
WorkingTreeFormat.register_format(WorkingTreeFormat4())
3077
 
WorkingTreeFormat.register_format(WorkingTreeFormat3())
3078
 
WorkingTreeFormat.set_default_format(__default_format)
3079
 
# formats which have no format string are not discoverable
3080
 
# and not independently creatable, so are not registered.
3081
 
_legacy_formats = [WorkingTreeFormat2(),
3082
 
                   ]
 
3136
    def get_controldir_for_branch(self):
 
3137
        """Get the control directory format for creating branches.
 
3138
 
 
3139
        This is to support testing of working tree formats that can not exist
 
3140
        in the same control directory as a branch.
 
3141
        """
 
3142
        return self._matchingbzrdir
 
3143
 
 
3144
 
 
3145
class WorkingTreeFormatMetaDir(bzrdir.BzrFormat, WorkingTreeFormat):
 
3146
    """Base class for working trees that live in bzr meta directories."""
 
3147
 
 
3148
    def __init__(self):
 
3149
        WorkingTreeFormat.__init__(self)
 
3150
        bzrdir.BzrFormat.__init__(self)
 
3151
 
 
3152
    @classmethod
 
3153
    def find_format_string(klass, controldir):
 
3154
        """Return format name for the working tree object in controldir."""
 
3155
        try:
 
3156
            transport = controldir.get_workingtree_transport(None)
 
3157
            return transport.get_bytes("format")
 
3158
        except errors.NoSuchFile:
 
3159
            raise errors.NoWorkingTree(base=transport.base)
 
3160
 
 
3161
    @classmethod
 
3162
    def find_format(klass, controldir):
 
3163
        """Return the format for the working tree object in controldir."""
 
3164
        format_string = klass.find_format_string(controldir)
 
3165
        return klass._find_format(format_registry, 'working tree',
 
3166
                format_string)
 
3167
 
 
3168
    def check_support_status(self, allow_unsupported, recommend_upgrade=True,
 
3169
            basedir=None):
 
3170
        WorkingTreeFormat.check_support_status(self,
 
3171
            allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
 
3172
            basedir=basedir)
 
3173
        bzrdir.BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
 
3174
            recommend_upgrade=recommend_upgrade, basedir=basedir)
 
3175
 
 
3176
    def get_controldir_for_branch(self):
 
3177
        """Get the control directory format for creating branches.
 
3178
 
 
3179
        This is to support testing of working tree formats that can not exist
 
3180
        in the same control directory as a branch.
 
3181
        """
 
3182
        return self._matchingbzrdir
 
3183
 
 
3184
 
 
3185
class WorkingTreeFormatMetaDir(bzrdir.BzrFormat, WorkingTreeFormat):
 
3186
    """Base class for working trees that live in bzr meta directories."""
 
3187
 
 
3188
    def __init__(self):
 
3189
        WorkingTreeFormat.__init__(self)
 
3190
        bzrdir.BzrFormat.__init__(self)
 
3191
 
 
3192
    @classmethod
 
3193
    def find_format_string(klass, controldir):
 
3194
        """Return format name for the working tree object in controldir."""
 
3195
        try:
 
3196
            transport = controldir.get_workingtree_transport(None)
 
3197
            return transport.get_bytes("format")
 
3198
        except errors.NoSuchFile:
 
3199
            raise errors.NoWorkingTree(base=transport.base)
 
3200
 
 
3201
    @classmethod
 
3202
    def find_format(klass, controldir):
 
3203
        """Return the format for the working tree object in controldir."""
 
3204
        format_string = klass.find_format_string(controldir)
 
3205
        return klass._find_format(format_registry, 'working tree',
 
3206
                format_string)
 
3207
 
 
3208
    def check_support_status(self, allow_unsupported, recommend_upgrade=True,
 
3209
            basedir=None):
 
3210
        WorkingTreeFormat.check_support_status(self,
 
3211
            allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
 
3212
            basedir=basedir)
 
3213
        bzrdir.BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
 
3214
            recommend_upgrade=recommend_upgrade, basedir=basedir)
 
3215
 
 
3216
 
 
3217
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",
 
3218
    "brzlib.workingtree_4", "WorkingTreeFormat4")
 
3219
format_registry.register_lazy("Bazaar Working Tree Format 5 (bzr 1.11)\n",
 
3220
    "brzlib.workingtree_4", "WorkingTreeFormat5")
 
3221
format_registry.register_lazy("Bazaar Working Tree Format 6 (bzr 1.14)\n",
 
3222
    "brzlib.workingtree_4", "WorkingTreeFormat6")
 
3223
format_registry.register_lazy("Bazaar-NG Working Tree format 3",
 
3224
    "brzlib.workingtree_3", "WorkingTreeFormat3")
 
3225
format_registry.set_default_key("Bazaar Working Tree Format 6 (bzr 1.14)\n")