← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Andrew Bennetts
  • Date: 2009-08-07 04:17:51 UTC
  • mto: This revision was merged to the branch mainline in revision 4608.
  • Revision ID: andrew.bennetts@canonical.com-20090807041751-0vhb0y0g7k49hr45
Review comments from John.

Show diffs side-by-side

added added

removed removed

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