← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

merge bzr.dev

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 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""WorkingTree object and friends.
18
18
 
19
19
A WorkingTree represents the editable working copy of a branch.
20
 
Operations which represent the WorkingTree are also done here,
21
 
such as renaming or adding files.  The WorkingTree has an inventory
22
 
which is updated by these operations.  A commit produces a
 
20
Operations which represent the WorkingTree are also done here, 
 
21
such as renaming or adding files.  The WorkingTree has an inventory 
 
22
which is updated by these operations.  A commit produces a 
23
23
new revision based on the workingtree and its inventory.
24
24
 
25
25
At the moment every WorkingTree has its own branch.  Remote
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
35
 
import sys
36
41
 
37
42
from bzrlib.lazy_import import lazy_import
38
43
lazy_import(globals(), """
39
44
from bisect import bisect_left
40
45
import collections
 
46
from copy import deepcopy
41
47
import errno
42
48
import itertools
43
49
import operator
44
50
import stat
 
51
from time import time
 
52
import warnings
45
53
import re
46
54
 
 
55
import bzrlib
47
56
from bzrlib import (
48
57
    branch,
49
58
    bzrdir,
50
59
    conflicts as _mod_conflicts,
51
 
    controldir,
 
60
    dirstate,
52
61
    errors,
53
 
    filters as _mod_filters,
54
62
    generate_ids,
55
63
    globbing,
56
 
    graph as _mod_graph,
57
64
    hashcache,
58
65
    ignores,
59
 
    inventory,
60
66
    merge,
61
 
    revision as _mod_revision,
 
67
    osutils,
62
68
    revisiontree,
63
 
    rio as _mod_rio,
 
69
    repository,
 
70
    textui,
 
71
    trace,
64
72
    transform,
65
 
    transport,
66
73
    ui,
67
 
    views,
 
74
    urlutils,
68
75
    xml5,
 
76
    xml6,
69
77
    xml7,
70
78
    )
 
79
import bzrlib.branch
 
80
from bzrlib.transport import get_transport
 
81
import bzrlib.ui
 
82
from bzrlib.workingtree_4 import WorkingTreeFormat4
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.inventory import InventoryEntry, Inventory, ROOT_ID, TreeReference
 
88
from bzrlib.lockable_files import LockableFiles, TransportLock
 
89
from bzrlib.lockdir import LockDir
76
90
import bzrlib.mutabletree
77
91
from bzrlib.mutabletree import needs_tree_write_lock
78
 
from bzrlib import osutils
79
92
from bzrlib.osutils import (
 
93
    compact_date,
80
94
    file_kind,
81
95
    isdir,
82
96
    normpath,
83
97
    pathjoin,
 
98
    rand_chars,
84
99
    realpath,
85
100
    safe_unicode,
86
101
    splitpath,
87
102
    supports_executable,
88
103
    )
89
104
from bzrlib.trace import mutter, note
90
 
from bzrlib.revision import CURRENT_REVISION
91
 
from bzrlib.symbol_versioning import (
92
 
    deprecated_passed,
93
 
    DEPRECATED_PARAMETER,
94
 
    )
 
105
from bzrlib.transport.local import LocalTransport
 
106
from bzrlib.progress import DummyProgress, ProgressPhase
 
107
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
 
108
from bzrlib.rio import RioReader, rio_file, Stanza
 
109
from bzrlib.symbol_versioning import (deprecated_passed,
 
110
        deprecated_method,
 
111
        deprecated_function,
 
112
        DEPRECATED_PARAMETER,
 
113
        zero_eight,
 
114
        zero_eleven,
 
115
        zero_thirteen,
 
116
        )
95
117
 
96
118
 
97
119
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
120
CONFLICT_HEADER_1 = "BZR conflict list format 1"
102
121
 
103
 
ERROR_PATH_NOT_FOUND = 3    # WindowsError errno code, equivalent to ENOENT
 
122
 
 
123
@deprecated_function(zero_thirteen)
 
124
def gen_file_id(name):
 
125
    """Return new file id for the basename 'name'.
 
126
 
 
127
    Use bzrlib.generate_ids.gen_file_id() instead
 
128
    """
 
129
    return generate_ids.gen_file_id(name)
 
130
 
 
131
 
 
132
@deprecated_function(zero_thirteen)
 
133
def gen_root_id():
 
134
    """Return a new tree-root file id.
 
135
 
 
136
    This has been deprecated in favor of bzrlib.generate_ids.gen_root_id()
 
137
    """
 
138
    return generate_ids.gen_root_id()
104
139
 
105
140
 
106
141
class TreeEntry(object):
107
142
    """An entry that implements the minimum interface used by commands.
108
143
 
109
 
    This needs further inspection, it may be better to have
 
144
    This needs further inspection, it may be better to have 
110
145
    InventoryEntries without ids - though that seems wrong. For now,
111
146
    this is a parallel hierarchy to InventoryEntry, and needs to become
112
147
    one of several things: decorates to that hierarchy, children of, or
115
150
    no InventoryEntry available - i.e. for unversioned objects.
116
151
    Perhaps they should be UnversionedEntry et al. ? - RBC 20051003
117
152
    """
118
 
 
 
153
 
119
154
    def __eq__(self, other):
120
155
        # yes, this us ugly, TODO: best practice __eq__ style.
121
156
        return (isinstance(other, TreeEntry)
122
157
                and other.__class__ == self.__class__)
123
 
 
 
158
 
124
159
    def kind_character(self):
125
160
        return "???"
126
161
 
158
193
        return ''
159
194
 
160
195
 
161
 
class WorkingTree(bzrlib.mutabletree.MutableTree,
162
 
    controldir.ControlComponent):
 
196
class WorkingTree(bzrlib.mutabletree.MutableTree):
163
197
    """Working copy tree.
164
198
 
165
 
    :ivar basedir: The root of the tree on disk. This is a unicode path object
166
 
        (as opposed to a URL).
 
199
    The inventory is held in the `Branch` working-inventory, and the
 
200
    files are in a directory on disk.
 
201
 
 
202
    It is possible for a `WorkingTree` to have a filename which is
 
203
    not listed in the Inventory and vice versa.
167
204
    """
168
205
 
169
 
    # override this to set the strategy for storing views
170
 
    def _make_views(self):
171
 
        return views.DisabledViews(self)
172
 
 
173
206
    def __init__(self, basedir='.',
174
207
                 branch=DEPRECATED_PARAMETER,
 
208
                 _inventory=None,
175
209
                 _control_files=None,
176
210
                 _internal=False,
177
211
                 _format=None,
185
219
        if not _internal:
186
220
            raise errors.BzrError("Please use bzrdir.open_workingtree or "
187
221
                "WorkingTree.open() to obtain a WorkingTree.")
 
222
        assert isinstance(basedir, basestring), \
 
223
            "base directory %r is not a string" % basedir
188
224
        basedir = safe_unicode(basedir)
189
225
        mutter("opening working tree %r", basedir)
190
226
        if deprecated_passed(branch):
192
228
        else:
193
229
            self._branch = self.bzrdir.open_branch()
194
230
        self.basedir = realpath(basedir)
195
 
        self._control_files = _control_files
196
 
        self._transport = self._control_files._transport
 
231
        # if branch is at our basedir and is a format 6 or less
 
232
        if isinstance(self._format, WorkingTreeFormat2):
 
233
            # share control object
 
234
            self._control_files = self.branch.control_files
 
235
        else:
 
236
            # assume all other formats have their own control files.
 
237
            assert isinstance(_control_files, LockableFiles), \
 
238
                    "_control_files must be a LockableFiles, not %r" \
 
239
                    % _control_files
 
240
            self._control_files = _control_files
197
241
        # update the whole cache up front and write to disk if anything changed;
198
242
        # in the future we might want to do this more selectively
199
243
        # two possible ways offer themselves : in self._unlock, write the cache
203
247
        wt_trans = self.bzrdir.get_workingtree_transport(None)
204
248
        cache_filename = wt_trans.local_abspath('stat-cache')
205
249
        self._hashcache = hashcache.HashCache(basedir, cache_filename,
206
 
            self.bzrdir._get_file_mode(),
207
 
            self._content_filter_stack_provider())
 
250
                                              self._control_files._file_mode)
208
251
        hc = self._hashcache
209
252
        hc.read()
210
253
        # is this scan needed ? it makes things kinda slow.
214
257
            mutter("write hc")
215
258
            hc.write()
216
259
 
217
 
        self._detect_case_handling()
218
 
        self._rules_searcher = None
219
 
        self.views = self._make_views()
220
 
 
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
 
    def _detect_case_handling(self):
242
 
        wt_trans = self.bzrdir.get_workingtree_transport(None)
243
 
        try:
244
 
            wt_trans.stat(self._format.case_sensitive_filename)
245
 
        except errors.NoSuchFile:
246
 
            self.case_sensitive = True
 
260
        if _inventory is None:
 
261
            # This will be acquired on lock_read() or lock_write()
 
262
            self._inventory_is_modified = False
 
263
            self._inventory = None
247
264
        else:
248
 
            self.case_sensitive = False
249
 
 
250
 
        self._setup_directory_is_tree_reference()
 
265
            # the caller of __init__ has provided an inventory,
 
266
            # we assume they know what they are doing - as its only
 
267
            # the Format factory and creation methods that are
 
268
            # permitted to do this.
 
269
            self._set_inventory(_inventory, dirty=False)
251
270
 
252
271
    branch = property(
253
272
        fget=lambda self: self._branch,
274
293
    def supports_tree_reference(self):
275
294
        return False
276
295
 
277
 
    def supports_content_filtering(self):
278
 
        return self._format.supports_content_filtering()
 
296
    def _set_inventory(self, inv, dirty):
 
297
        """Set the internal cached inventory.
279
298
 
280
 
    def supports_views(self):
281
 
        return self.views.supports_views()
 
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
        assert inv.root is not None
 
307
        self._inventory = inv
 
308
        self._inventory_is_modified = dirty
282
309
 
283
310
    @staticmethod
284
311
    def open(path=None, _unsupported=False):
286
313
 
287
314
        """
288
315
        if path is None:
289
 
            path = osutils.getcwd()
 
316
            path = os.path.getcwdu()
290
317
        control = bzrdir.BzrDir.open(path, _unsupported)
291
318
        return control.open_workingtree(_unsupported)
292
 
 
 
319
        
293
320
    @staticmethod
294
321
    def open_containing(path=None):
295
322
        """Open an existing working tree which has its root about path.
296
 
 
 
323
        
297
324
        This probes for a working tree at path and searches upwards from there.
298
325
 
299
326
        Basically we keep looking up until we find the control directory or
306
333
        if path is None:
307
334
            path = osutils.getcwd()
308
335
        control, relpath = bzrdir.BzrDir.open_containing(path)
 
336
 
309
337
        return control.open_workingtree(), relpath
310
338
 
311
339
    @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
340
    def open_downlevel(path=None):
379
341
        """Open an unsupported working tree.
380
342
 
382
344
        """
383
345
        return WorkingTree.open(path, _unsupported=True)
384
346
 
385
 
    @staticmethod
386
 
    def find_trees(location):
387
 
        def list_current(transport):
388
 
            return [d for d in transport.list_dir('') if d != '.bzr']
389
 
        def evaluate(bzrdir):
390
 
            try:
391
 
                tree = bzrdir.open_workingtree()
392
 
            except errors.NoWorkingTree:
393
 
                return True, None
394
 
            else:
395
 
                return True, tree
396
 
        t = transport.get_transport(location)
397
 
        iterator = bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate,
398
 
                                              list_current=list_current)
399
 
        return [tr for tr in iterator if tr is not None]
 
347
    # should be deprecated - this is slow and in any case treating them as a
 
348
    # container is (we now know) bad style -- mbp 20070302
 
349
    ## @deprecated_method(zero_fifteen)
 
350
    def __iter__(self):
 
351
        """Iterate through file_ids for this tree.
400
352
 
401
 
    def all_file_ids(self):
402
 
        """See Tree.iter_all_file_ids"""
403
 
        raise NotImplementedError(self.all_file_ids)
 
353
        file_ids are in a WorkingTree if they are in the working inventory
 
354
        and the working file exists.
 
355
        """
 
356
        inv = self._inventory
 
357
        for path, ie in inv.iter_entries():
 
358
            if osutils.lexists(self.abspath(path)):
 
359
                yield ie.file_id
404
360
 
405
361
    def __repr__(self):
406
362
        return "<%s of %s>" % (self.__class__.__name__,
408
364
 
409
365
    def abspath(self, filename):
410
366
        return pathjoin(self.basedir, filename)
411
 
 
 
367
    
412
368
    def basis_tree(self):
413
369
        """Return RevisionTree for the current last revision.
414
 
 
 
370
        
415
371
        If the left most parent is a ghost then the returned tree will be an
416
 
        empty tree - one obtained by calling
417
 
        repository.revision_tree(NULL_REVISION).
 
372
        empty tree - one obtained by calling repository.revision_tree(None).
418
373
        """
419
374
        try:
420
375
            revision_id = self.get_parent_ids()[0]
422
377
            # no parents, return an empty revision tree.
423
378
            # in the future this should return the tree for
424
379
            # 'empty:' - the implicit root empty tree.
425
 
            return self.branch.repository.revision_tree(
426
 
                       _mod_revision.NULL_REVISION)
 
380
            return self.branch.repository.revision_tree(None)
427
381
        try:
428
382
            return self.revision_tree(revision_id)
429
383
        except errors.NoSuchRevision:
433
387
        # at this point ?
434
388
        try:
435
389
            return self.branch.repository.revision_tree(revision_id)
436
 
        except (errors.RevisionNotPresent, errors.NoSuchRevision):
 
390
        except errors.RevisionNotPresent:
437
391
            # the basis tree *may* be a ghost or a low level error may have
438
 
            # occurred. If the revision is present, its a problem, if its not
 
392
            # occured. If the revision is present, its a problem, if its not
439
393
            # its a ghost.
440
394
            if self.branch.repository.has_revision(revision_id):
441
395
                raise
442
396
            # the basis tree is a ghost so return an empty tree.
443
 
            return self.branch.repository.revision_tree(
444
 
                       _mod_revision.NULL_REVISION)
445
 
 
446
 
    def _cleanup(self):
447
 
        self._flush_ignore_list_cache()
 
397
            return self.branch.repository.revision_tree(None)
 
398
 
 
399
    @staticmethod
 
400
    @deprecated_method(zero_eight)
 
401
    def create(branch, directory):
 
402
        """Create a workingtree for branch at directory.
 
403
 
 
404
        If existing_directory already exists it must have a .bzr directory.
 
405
        If it does not exist, it will be created.
 
406
 
 
407
        This returns a new WorkingTree object for the new checkout.
 
408
 
 
409
        TODO FIXME RBC 20060124 when we have checkout formats in place this
 
410
        should accept an optional revisionid to checkout [and reject this if
 
411
        checking out into the same dir as a pre-checkout-aware branch format.]
 
412
 
 
413
        XXX: When BzrDir is present, these should be created through that 
 
414
        interface instead.
 
415
        """
 
416
        warnings.warn('delete WorkingTree.create', stacklevel=3)
 
417
        transport = get_transport(directory)
 
418
        if branch.bzrdir.root_transport.base == transport.base:
 
419
            # same dir 
 
420
            return branch.bzrdir.create_workingtree()
 
421
        # different directory, 
 
422
        # create a branch reference
 
423
        # and now a working tree.
 
424
        raise NotImplementedError
 
425
 
 
426
    @staticmethod
 
427
    @deprecated_method(zero_eight)
 
428
    def create_standalone(directory):
 
429
        """Create a checkout and a branch and a repo at directory.
 
430
 
 
431
        Directory must exist and be empty.
 
432
 
 
433
        please use BzrDir.create_standalone_workingtree
 
434
        """
 
435
        return bzrdir.BzrDir.create_standalone_workingtree(directory)
448
436
 
449
437
    def relpath(self, path):
450
438
        """Return the local path portion from a given path.
451
 
 
452
 
        The path may be absolute or relative. If its a relative path it is
 
439
        
 
440
        The path may be absolute or relative. If its a relative path it is 
453
441
        interpreted relative to the python current working directory.
454
442
        """
455
443
        return osutils.relpath(self.basedir, path)
457
445
    def has_filename(self, filename):
458
446
        return osutils.lexists(self.abspath(filename))
459
447
 
460
 
    def get_file(self, file_id, path=None, filtered=True):
461
 
        return self.get_file_with_stat(file_id, path, filtered=filtered)[0]
462
 
 
463
 
    def get_file_with_stat(self, file_id, path=None, filtered=True,
464
 
                           _fstat=osutils.fstat):
465
 
        """See Tree.get_file_with_stat."""
466
 
        if path is None:
467
 
            path = self.id2path(file_id)
468
 
        file_obj = self.get_file_byname(path, filtered=False)
469
 
        stat_value = _fstat(file_obj.fileno())
470
 
        if filtered and self.supports_content_filtering():
471
 
            filters = self._content_filter_stack(path)
472
 
            file_obj = _mod_filters.filtered_input_file(file_obj, filters)
473
 
        return (file_obj, stat_value)
474
 
 
475
 
    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()
481
 
 
482
 
    def get_file_byname(self, filename, filtered=True):
483
 
        path = self.abspath(filename)
484
 
        f = file(path, 'rb')
485
 
        if filtered and self.supports_content_filtering():
486
 
            filters = self._content_filter_stack(filename)
487
 
            return _mod_filters.filtered_input_file(f, filters)
488
 
        else:
489
 
            return f
490
 
 
491
 
    def get_file_lines(self, file_id, path=None, filtered=True):
492
 
        """See Tree.get_file_lines()"""
493
 
        file = self.get_file(file_id, path, filtered=filtered)
494
 
        try:
495
 
            return file.readlines()
496
 
        finally:
497
 
            file.close()
 
448
    def get_file(self, file_id):
 
449
        file_id = osutils.safe_file_id(file_id)
 
450
        return self.get_file_byname(self.id2path(file_id))
 
451
 
 
452
    def get_file_text(self, file_id):
 
453
        file_id = osutils.safe_file_id(file_id)
 
454
        return self.get_file(file_id).read()
 
455
 
 
456
    def get_file_byname(self, filename):
 
457
        return file(self.abspath(filename), 'rb')
 
458
 
 
459
    @needs_read_lock
 
460
    def annotate_iter(self, file_id):
 
461
        """See Tree.annotate_iter
 
462
 
 
463
        This implementation will use the basis tree implementation if possible.
 
464
        Lines not in the basis are attributed to CURRENT_REVISION
 
465
 
 
466
        If there are pending merges, lines added by those merges will be
 
467
        incorrectly attributed to CURRENT_REVISION (but after committing, the
 
468
        attribution will be correct).
 
469
        """
 
470
        file_id = osutils.safe_file_id(file_id)
 
471
        basis = self.basis_tree()
 
472
        basis.lock_read()
 
473
        try:
 
474
            changes = self._iter_changes(basis, True, [self.id2path(file_id)],
 
475
                require_versioned=True).next()
 
476
            changed_content, kind = changes[2], changes[6]
 
477
            if not changed_content:
 
478
                return basis.annotate_iter(file_id)
 
479
            if kind[1] is None:
 
480
                return None
 
481
            import annotate
 
482
            if kind[0] != 'file':
 
483
                old_lines = []
 
484
            else:
 
485
                old_lines = list(basis.annotate_iter(file_id))
 
486
            old = [old_lines]
 
487
            for tree in self.branch.repository.revision_trees(
 
488
                self.get_parent_ids()[1:]):
 
489
                if file_id not in tree:
 
490
                    continue
 
491
                old.append(list(tree.annotate_iter(file_id)))
 
492
            return annotate.reannotate(old, self.get_file(file_id).readlines(),
 
493
                                       CURRENT_REVISION)
 
494
        finally:
 
495
            basis.unlock()
498
496
 
499
497
    def get_parent_ids(self):
500
498
        """See Tree.get_parent_ids.
501
 
 
 
499
        
502
500
        This implementation reads the pending merges list and last_revision
503
501
        value and uses that to decide what the parents list should be.
504
502
        """
505
 
        last_rev = _mod_revision.ensure_null(self._last_revision())
506
 
        if _mod_revision.NULL_REVISION == last_rev:
 
503
        last_rev = self._last_revision()
 
504
        if last_rev is None:
507
505
            parents = []
508
506
        else:
509
507
            parents = [last_rev]
510
508
        try:
511
 
            merges_bytes = self._transport.get_bytes('pending-merges')
 
509
            merges_file = self._control_files.get('pending-merges')
512
510
        except errors.NoSuchFile:
513
511
            pass
514
512
        else:
515
 
            for l in osutils.split_lines(merges_bytes):
516
 
                revision_id = l.rstrip('\n')
 
513
            for l in merges_file.readlines():
 
514
                revision_id = osutils.safe_revision_id(l.rstrip('\n'))
517
515
                parents.append(revision_id)
518
516
        return parents
519
517
 
 
518
    @needs_read_lock
520
519
    def get_root_id(self):
521
520
        """Return the id of this trees root"""
522
 
        raise NotImplementedError(self.get_root_id)
 
521
        return self._inventory.root.file_id
 
522
        
 
523
    def _get_store_filename(self, file_id):
 
524
        ## XXX: badly named; this is not in the store at all
 
525
        file_id = osutils.safe_file_id(file_id)
 
526
        return self.abspath(self.id2path(file_id))
523
527
 
524
528
    @needs_read_lock
525
529
    def clone(self, to_bzrdir, revision_id=None):
526
530
        """Duplicate this working tree into to_bzr, including all state.
527
 
 
 
531
        
528
532
        Specifically modified files are kept as modified, but
529
533
        ignored and unknown files are discarded.
530
534
 
531
535
        If you want to make a new line of development, see bzrdir.sprout()
532
536
 
533
537
        revision
534
 
            If not None, the cloned tree will have its last revision set to
535
 
            revision, and difference between the source trees last revision
 
538
            If not None, the cloned tree will have its last revision set to 
 
539
            revision, and and difference between the source trees last revision
536
540
            and this one merged in.
537
541
        """
538
542
        # assumes the target bzr dir format is compatible.
539
 
        result = to_bzrdir.create_workingtree()
 
543
        result = self._format.initialize(to_bzrdir)
540
544
        self.copy_content_into(result, revision_id)
541
545
        return result
542
546
 
553
557
            tree.set_parent_ids([revision_id])
554
558
 
555
559
    def id2abspath(self, file_id):
 
560
        file_id = osutils.safe_file_id(file_id)
556
561
        return self.abspath(self.id2path(file_id))
557
562
 
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)
 
563
    def has_id(self, file_id):
 
564
        # files that have been deleted are excluded
 
565
        file_id = osutils.safe_file_id(file_id)
 
566
        inv = self.inventory
 
567
        if not inv.has_id(file_id):
 
568
            return False
 
569
        path = inv.id2path(file_id)
 
570
        return osutils.lexists(self.abspath(path))
 
571
 
 
572
    def has_or_had_id(self, file_id):
 
573
        file_id = osutils.safe_file_id(file_id)
 
574
        if file_id == self.inventory.root.file_id:
 
575
            return True
 
576
        return self.inventory.has_id(file_id)
 
577
 
 
578
    __contains__ = has_id
585
579
 
586
580
    def get_file_size(self, file_id):
587
 
        """See Tree.get_file_size"""
588
 
        # XXX: this returns the on-disk size; it should probably return the
589
 
        # canonical size
590
 
        try:
591
 
            return os.path.getsize(self.id2abspath(file_id))
592
 
        except OSError, e:
593
 
            if e.errno != errno.ENOENT:
594
 
                raise
 
581
        file_id = osutils.safe_file_id(file_id)
 
582
        return os.path.getsize(self.id2abspath(file_id))
 
583
 
 
584
    @needs_read_lock
 
585
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
586
        file_id = osutils.safe_file_id(file_id)
 
587
        if not path:
 
588
            path = self._inventory.id2path(file_id)
 
589
        return self._hashcache.get_sha1(path, stat_value)
 
590
 
 
591
    def get_file_mtime(self, file_id, path=None):
 
592
        file_id = osutils.safe_file_id(file_id)
 
593
        if not path:
 
594
            path = self.inventory.id2path(file_id)
 
595
        return os.lstat(self.abspath(path)).st_mtime
 
596
 
 
597
    if not supports_executable():
 
598
        def is_executable(self, file_id, path=None):
 
599
            file_id = osutils.safe_file_id(file_id)
 
600
            return self._inventory[file_id].executable
 
601
    else:
 
602
        def is_executable(self, file_id, path=None):
 
603
            if not path:
 
604
                file_id = osutils.safe_file_id(file_id)
 
605
                path = self.id2path(file_id)
 
606
            mode = os.lstat(self.abspath(path)).st_mode
 
607
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
608
 
 
609
    @needs_tree_write_lock
 
610
    def _add(self, files, ids, kinds):
 
611
        """See MutableTree._add."""
 
612
        # TODO: Re-adding a file that is removed in the working copy
 
613
        # should probably put it back with the previous ID.
 
614
        # the read and write working inventory should not occur in this 
 
615
        # function - they should be part of lock_write and unlock.
 
616
        inv = self.read_working_inventory()
 
617
        for f, file_id, kind in zip(files, ids, kinds):
 
618
            assert kind is not None
 
619
            if file_id is None:
 
620
                inv.add_path(f, kind=kind)
595
621
            else:
596
 
                return None
597
 
 
598
 
    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)
 
622
                file_id = osutils.safe_file_id(file_id)
 
623
                inv.add_path(f, kind=kind, file_id=file_id)
 
624
        self._write_inventory(inv)
601
625
 
602
626
    @needs_tree_write_lock
603
627
    def _gather_kinds(self, files, kinds):
619
643
        and setting the list to its value plus revision_id.
620
644
 
621
645
        :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.
 
646
        be a ghost revision as long as its not the first parent to be added,
 
647
        or the allow_leftmost_as_ghost parameter is set True.
624
648
        :param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
625
649
        """
626
650
        parents = self.get_parent_ids() + [revision_id]
663
687
        if updated:
664
688
            self.set_parent_ids(parents, allow_leftmost_as_ghost=True)
665
689
 
666
 
    def path_content_summary(self, path, _lstat=os.lstat,
667
 
        _mapper=osutils.file_kind_from_stat_mode):
668
 
        """See Tree.path_content_summary."""
669
 
        abspath = self.abspath(path)
670
 
        try:
671
 
            stat_result = _lstat(abspath)
672
 
        except OSError, e:
673
 
            if getattr(e, 'errno', None) == errno.ENOENT:
674
 
                # no file.
675
 
                return ('missing', None, None, None)
676
 
            # propagate other errors
677
 
            raise
678
 
        kind = _mapper(stat_result.st_mode)
679
 
        if kind == 'file':
680
 
            return self._file_content_summary(path, stat_result)
681
 
        elif kind == 'directory':
682
 
            # perhaps it looks like a plain directory, but it's really a
683
 
            # reference.
684
 
            if self._directory_is_tree_reference(path):
685
 
                kind = 'tree-reference'
686
 
            return kind, None, None, None
687
 
        elif kind == 'symlink':
688
 
            target = osutils.readlink(abspath)
689
 
            return ('symlink', None, None, target)
690
 
        else:
691
 
            return (kind, None, None, None)
692
 
 
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))
 
690
    @deprecated_method(zero_eleven)
 
691
    @needs_read_lock
 
692
    def pending_merges(self):
 
693
        """Return a list of pending merges.
 
694
 
 
695
        These are revisions that have been merged into the working
 
696
        directory but not yet committed.
 
697
 
 
698
        As of 0.11 this is deprecated. Please see WorkingTree.get_parent_ids()
 
699
        instead - which is available on all tree objects.
 
700
        """
 
701
        return self.get_parent_ids()[1:]
699
702
 
700
703
    def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):
701
704
        """Common ghost checking functionality from set_parent_*.
711
714
 
712
715
    def _set_merges_from_parent_ids(self, parent_ids):
713
716
        merges = parent_ids[1:]
714
 
        self._transport.put_bytes('pending-merges', '\n'.join(merges),
715
 
            mode=self.bzrdir._get_file_mode())
716
 
 
717
 
    def _filter_parent_ids_by_ancestry(self, revision_ids):
718
 
        """Check that all merged revisions are proper 'heads'.
719
 
 
720
 
        This will always return the first revision_id, and any merged revisions
721
 
        which are
722
 
        """
723
 
        if len(revision_ids) == 0:
724
 
            return revision_ids
725
 
        graph = self.branch.repository.get_graph()
726
 
        heads = graph.heads(revision_ids)
727
 
        new_revision_ids = revision_ids[:1]
728
 
        for revision_id in revision_ids[1:]:
729
 
            if revision_id in heads and revision_id not in new_revision_ids:
730
 
                new_revision_ids.append(revision_id)
731
 
        if new_revision_ids != revision_ids:
732
 
            mutter('requested to set revision_ids = %s,'
733
 
                         ' but filtered to %s', revision_ids, new_revision_ids)
734
 
        return new_revision_ids
 
717
        self._control_files.put_bytes('pending-merges', '\n'.join(merges))
735
718
 
736
719
    @needs_tree_write_lock
737
720
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
738
721
        """Set the parent ids to revision_ids.
739
 
 
 
722
        
740
723
        See also set_parent_trees. This api will try to retrieve the tree data
741
724
        for each element of revision_ids from the trees repository. If you have
742
725
        tree data already available, it is more efficient to use
746
729
        :param revision_ids: The revision_ids to set as the parent ids of this
747
730
            working tree. Any of these may be ghosts.
748
731
        """
 
732
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
749
733
        self._check_parents_for_ghosts(revision_ids,
750
734
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
751
 
        for revision_id in revision_ids:
752
 
            _mod_revision.check_not_reserved_id(revision_id)
753
 
 
754
 
        revision_ids = self._filter_parent_ids_by_ancestry(revision_ids)
755
735
 
756
736
        if len(revision_ids) > 0:
757
737
            self.set_last_revision(revision_ids[0])
758
738
        else:
759
 
            self.set_last_revision(_mod_revision.NULL_REVISION)
 
739
            self.set_last_revision(None)
760
740
 
761
741
        self._set_merges_from_parent_ids(revision_ids)
762
742
 
763
743
    @needs_tree_write_lock
 
744
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
 
745
        """See MutableTree.set_parent_trees."""
 
746
        parent_ids = [osutils.safe_revision_id(rev) for (rev, tree) in parents_list]
 
747
 
 
748
        self._check_parents_for_ghosts(parent_ids,
 
749
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
750
 
 
751
        if len(parent_ids) == 0:
 
752
            leftmost_parent_id = None
 
753
            leftmost_parent_tree = None
 
754
        else:
 
755
            leftmost_parent_id, leftmost_parent_tree = parents_list[0]
 
756
 
 
757
        if self._change_last_revision(leftmost_parent_id):
 
758
            if leftmost_parent_tree is None:
 
759
                # If we don't have a tree, fall back to reading the
 
760
                # parent tree from the repository.
 
761
                self._cache_basis_inventory(leftmost_parent_id)
 
762
            else:
 
763
                inv = leftmost_parent_tree.inventory
 
764
                xml = self._create_basis_xml_from_inventory(
 
765
                                        leftmost_parent_id, inv)
 
766
                self._write_basis_inventory(xml)
 
767
        self._set_merges_from_parent_ids(parent_ids)
 
768
 
 
769
    @needs_tree_write_lock
764
770
    def set_pending_merges(self, rev_list):
765
771
        parents = self.get_parent_ids()
766
772
        leftmost = parents[:1]
771
777
    def set_merge_modified(self, modified_hashes):
772
778
        def iter_stanzas():
773
779
            for file_id, hash in modified_hashes.iteritems():
774
 
                yield _mod_rio.Stanza(file_id=file_id.decode('utf8'),
775
 
                    hash=hash)
 
780
                yield Stanza(file_id=file_id.decode('utf8'), hash=hash)
776
781
        self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
777
782
 
778
 
    def _sha_from_stat(self, path, stat_result):
779
 
        """Get a sha digest from the tree's stat cache.
780
 
 
781
 
        The default implementation assumes no stat cache is present.
782
 
 
783
 
        :param path: The path.
784
 
        :param stat_result: The stat result being looked up.
785
 
        """
786
 
        return None
787
 
 
788
783
    def _put_rio(self, filename, stanzas, header):
789
784
        self._must_be_locked()
790
 
        my_file = _mod_rio.rio_file(stanzas, header)
791
 
        self._transport.put_file(filename, my_file,
792
 
            mode=self.bzrdir._get_file_mode())
 
785
        my_file = rio_file(stanzas, header)
 
786
        self._control_files.put(filename, my_file)
793
787
 
794
788
    @needs_write_lock # because merge pulls data into the branch.
795
 
    def merge_from_branch(self, branch, to_revision=None, from_revision=None,
796
 
                          merge_type=None, force=False):
 
789
    def merge_from_branch(self, branch, to_revision=None):
797
790
        """Merge from a branch into this working tree.
798
791
 
799
792
        :param branch: The branch to merge from.
803
796
            branch.last_revision().
804
797
        """
805
798
        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:
 
799
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
800
        try:
 
801
            merger = Merger(self.branch, this_tree=self, pb=pb)
 
802
            merger.pp = ProgressPhase("Merge phase", 5, pb)
 
803
            merger.pp.next_phase()
 
804
            # check that there are no
 
805
            # local alterations
 
806
            merger.check_basis(check_clean=True, require_commits=False)
 
807
            if to_revision is None:
 
808
                to_revision = branch.last_revision()
 
809
            else:
 
810
                to_revision = osutils.safe_revision_id(to_revision)
 
811
            merger.other_rev_id = to_revision
 
812
            if merger.other_rev_id is None:
 
813
                raise error.NoCommits(branch)
 
814
            self.branch.fetch(branch, last_revision=merger.other_rev_id)
 
815
            merger.other_basis = merger.other_rev_id
 
816
            merger.other_tree = self.branch.repository.revision_tree(
 
817
                merger.other_rev_id)
 
818
            merger.other_branch = branch
 
819
            merger.pp.next_phase()
821
820
            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:
 
821
            if merger.base_rev_id == merger.other_rev_id:
 
822
                raise errors.PointlessMerge
 
823
            merger.backup_files = False
828
824
            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()
 
825
            merger.set_interesting_files(None)
 
826
            merger.show_base = False
 
827
            merger.reprocess = False
 
828
            conflicts = merger.do_merge()
 
829
            merger.set_pending()
 
830
        finally:
 
831
            pb.finished()
836
832
        return conflicts
837
833
 
 
834
    @needs_read_lock
838
835
    def merge_modified(self):
839
836
        """Return a dictionary of files modified by a merge.
840
837
 
841
 
        The list is initialized by WorkingTree.set_merge_modified, which is
 
838
        The list is initialized by WorkingTree.set_merge_modified, which is 
842
839
        typically called after we make some automatic updates to the tree
843
840
        because of a merge.
844
841
 
845
842
        This returns a map of file_id->sha1, containing only files which are
846
843
        still in the working inventory and have that text hash.
847
844
        """
848
 
        raise NotImplementedError(self.merge_modified)
 
845
        try:
 
846
            hashfile = self._control_files.get('merge-hashes')
 
847
        except errors.NoSuchFile:
 
848
            return {}
 
849
        merge_hashes = {}
 
850
        try:
 
851
            if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
 
852
                raise errors.MergeModifiedFormatError()
 
853
        except StopIteration:
 
854
            raise errors.MergeModifiedFormatError()
 
855
        for s in RioReader(hashfile):
 
856
            # RioReader reads in Unicode, so convert file_ids back to utf8
 
857
            file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
 
858
            if file_id not in self.inventory:
 
859
                continue
 
860
            text_hash = s.get("hash")
 
861
            if text_hash == self.get_file_sha1(file_id):
 
862
                merge_hashes[file_id] = text_hash
 
863
        return merge_hashes
849
864
 
850
865
    @needs_write_lock
851
866
    def mkdir(self, path, file_id=None):
856
871
        self.add(path, file_id, 'directory')
857
872
        return file_id
858
873
 
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)
864
 
        target = osutils.readlink(abspath)
865
 
        return target
 
874
    def get_symlink_target(self, file_id):
 
875
        file_id = osutils.safe_file_id(file_id)
 
876
        return os.readlink(self.id2abspath(file_id))
866
877
 
 
878
    @needs_write_lock
867
879
    def subsume(self, other_tree):
868
 
        raise NotImplementedError(self.subsume)
869
 
 
870
 
    def _setup_directory_is_tree_reference(self):
871
 
        if self._branch.repository._format.supports_tree_reference:
872
 
            self._directory_is_tree_reference = \
873
 
                self._directory_may_be_tree_reference
874
 
        else:
875
 
            self._directory_is_tree_reference = \
876
 
                self._directory_is_never_tree_reference
877
 
 
878
 
    def _directory_is_never_tree_reference(self, relpath):
879
 
        return False
880
 
 
881
 
    def _directory_may_be_tree_reference(self, relpath):
882
 
        # as a special case, if a directory contains control files then
883
 
        # it's a tree reference, except that the root of the tree is not
884
 
        return relpath and osutils.isdir(self.abspath(relpath) + u"/.bzr")
885
 
        # TODO: We could ask all the control formats whether they
886
 
        # recognize this directory, but at the moment there's no cheap api
887
 
        # to do that.  Since we probably can only nest bzr checkouts and
888
 
        # they always use this name it's ok for now.  -- mbp 20060306
889
 
        #
890
 
        # FIXME: There is an unhandled case here of a subdirectory
891
 
        # containing .bzr but not a branch; that will probably blow up
892
 
        # when you try to commit it.  It might happen if there is a
893
 
        # checkout in a subdirectory.  This can be avoided by not adding
894
 
        # it.  mbp 20070306
895
 
 
 
880
        def add_children(inventory, entry):
 
881
            for child_entry in entry.children.values():
 
882
                inventory._byid[child_entry.file_id] = child_entry
 
883
                if child_entry.kind == 'directory':
 
884
                    add_children(inventory, child_entry)
 
885
        if other_tree.get_root_id() == self.get_root_id():
 
886
            raise errors.BadSubsumeSource(self, other_tree,
 
887
                                          'Trees have the same root')
 
888
        try:
 
889
            other_tree_path = self.relpath(other_tree.basedir)
 
890
        except errors.PathNotChild:
 
891
            raise errors.BadSubsumeSource(self, other_tree,
 
892
                'Tree is not contained by the other')
 
893
        new_root_parent = self.path2id(osutils.dirname(other_tree_path))
 
894
        if new_root_parent is None:
 
895
            raise errors.BadSubsumeSource(self, other_tree,
 
896
                'Parent directory is not versioned.')
 
897
        # We need to ensure that the result of a fetch will have a
 
898
        # versionedfile for the other_tree root, and only fetching into
 
899
        # RepositoryKnit2 guarantees that.
 
900
        if not self.branch.repository.supports_rich_root():
 
901
            raise errors.SubsumeTargetNeedsUpgrade(other_tree)
 
902
        other_tree.lock_tree_write()
 
903
        try:
 
904
            new_parents = other_tree.get_parent_ids()
 
905
            other_root = other_tree.inventory.root
 
906
            other_root.parent_id = new_root_parent
 
907
            other_root.name = osutils.basename(other_tree_path)
 
908
            self.inventory.add(other_root)
 
909
            add_children(self.inventory, other_root)
 
910
            self._write_inventory(self.inventory)
 
911
            # normally we don't want to fetch whole repositories, but i think
 
912
            # here we really do want to consolidate the whole thing.
 
913
            for parent_id in other_tree.get_parent_ids():
 
914
                self.branch.fetch(other_tree.branch, parent_id)
 
915
                self.add_parent_tree_id(parent_id)
 
916
        finally:
 
917
            other_tree.unlock()
 
918
        other_tree.bzrdir.retire_bzrdir()
 
919
 
 
920
    @needs_tree_write_lock
896
921
    def extract(self, file_id, format=None):
897
922
        """Extract a subtree from this tree.
898
 
 
 
923
        
899
924
        A new branch will be created, relative to the path for this tree.
900
925
        """
901
 
        raise NotImplementedError(self.extract)
 
926
        self.flush()
 
927
        def mkdirs(path):
 
928
            segments = osutils.splitpath(path)
 
929
            transport = self.branch.bzrdir.root_transport
 
930
            for name in segments:
 
931
                transport = transport.clone(name)
 
932
                try:
 
933
                    transport.mkdir('.')
 
934
                except errors.FileExists:
 
935
                    pass
 
936
            return transport
 
937
            
 
938
        sub_path = self.id2path(file_id)
 
939
        branch_transport = mkdirs(sub_path)
 
940
        if format is None:
 
941
            format = bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
 
942
        try:
 
943
            branch_transport.mkdir('.')
 
944
        except errors.FileExists:
 
945
            pass
 
946
        branch_bzrdir = format.initialize_on_transport(branch_transport)
 
947
        try:
 
948
            repo = branch_bzrdir.find_repository()
 
949
        except errors.NoRepositoryPresent:
 
950
            repo = branch_bzrdir.create_repository()
 
951
            assert repo.supports_rich_root()
 
952
        else:
 
953
            if not repo.supports_rich_root():
 
954
                raise errors.RootNotRich()
 
955
        new_branch = branch_bzrdir.create_branch()
 
956
        new_branch.pull(self.branch)
 
957
        for parent_id in self.get_parent_ids():
 
958
            new_branch.fetch(self.branch, parent_id)
 
959
        tree_transport = self.bzrdir.root_transport.clone(sub_path)
 
960
        if tree_transport.base != branch_transport.base:
 
961
            tree_bzrdir = format.initialize_on_transport(tree_transport)
 
962
            branch.BranchReferenceFormat().initialize(tree_bzrdir, new_branch)
 
963
        else:
 
964
            tree_bzrdir = branch_bzrdir
 
965
        wt = tree_bzrdir.create_workingtree(NULL_REVISION)
 
966
        wt.set_parent_ids(self.get_parent_ids())
 
967
        my_inv = self.inventory
 
968
        child_inv = Inventory(root_id=None)
 
969
        new_root = my_inv[file_id]
 
970
        my_inv.remove_recursive_id(file_id)
 
971
        new_root.parent_id = None
 
972
        child_inv.add(new_root)
 
973
        self._write_inventory(my_inv)
 
974
        wt._write_inventory(child_inv)
 
975
        return wt
 
976
 
 
977
    def _serialize(self, inventory, out_file):
 
978
        xml5.serializer_v5.write_inventory(self._inventory, out_file)
 
979
 
 
980
    def _deserialize(selt, in_file):
 
981
        return xml5.serializer_v5.read_inventory(in_file)
902
982
 
903
983
    def flush(self):
904
 
        """Write the in memory meta data to disk."""
905
 
        raise NotImplementedError(self.flush)
 
984
        """Write the in memory inventory to disk."""
 
985
        # TODO: Maybe this should only write on dirty ?
 
986
        if self._control_files._lock_mode != 'w':
 
987
            raise errors.NotWriteLocked(self)
 
988
        sio = StringIO()
 
989
        self._serialize(self._inventory, sio)
 
990
        sio.seek(0)
 
991
        self._control_files.put('inventory', sio)
 
992
        self._inventory_is_modified = False
906
993
 
907
994
    def _kind(self, relpath):
908
995
        return osutils.file_kind(self.abspath(relpath))
909
996
 
910
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
911
 
        """List all files as (path, class, kind, id, entry).
 
997
    def list_files(self, include_root=False):
 
998
        """Recursively list all files as (path, class, kind, id, entry).
912
999
 
913
1000
        Lists, but does not descend into unversioned directories.
 
1001
 
914
1002
        This does not include files that have been deleted in this
915
 
        tree. Skips the control directory.
 
1003
        tree.
916
1004
 
917
 
        :param include_root: if True, return an entry for the root
918
 
        :param from_dir: start from this directory or None for the root
919
 
        :param recursive: whether to recurse into subdirectories or not
 
1005
        Skips the control directory.
920
1006
        """
921
 
        raise NotImplementedError(self.list_files)
922
 
 
923
 
    def move(self, from_paths, to_dir=None, after=False):
 
1007
        # list_files is an iterator, so @needs_read_lock doesn't work properly
 
1008
        # with it. So callers should be careful to always read_lock the tree.
 
1009
        if not self.is_locked():
 
1010
            raise errors.ObjectNotLocked(self)
 
1011
 
 
1012
        inv = self.inventory
 
1013
        if include_root is True:
 
1014
            yield ('', 'V', 'directory', inv.root.file_id, inv.root)
 
1015
        # Convert these into local objects to save lookup times
 
1016
        pathjoin = osutils.pathjoin
 
1017
        file_kind = self._kind
 
1018
 
 
1019
        # transport.base ends in a slash, we want the piece
 
1020
        # between the last two slashes
 
1021
        transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
 
1022
 
 
1023
        fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
 
1024
 
 
1025
        # directory file_id, relative path, absolute path, reverse sorted children
 
1026
        children = os.listdir(self.basedir)
 
1027
        children.sort()
 
1028
        # jam 20060527 The kernel sized tree seems equivalent whether we 
 
1029
        # use a deque and popleft to keep them sorted, or if we use a plain
 
1030
        # list and just reverse() them.
 
1031
        children = collections.deque(children)
 
1032
        stack = [(inv.root.file_id, u'', self.basedir, children)]
 
1033
        while stack:
 
1034
            from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
 
1035
 
 
1036
            while children:
 
1037
                f = children.popleft()
 
1038
                ## TODO: If we find a subdirectory with its own .bzr
 
1039
                ## directory, then that is a separate tree and we
 
1040
                ## should exclude it.
 
1041
 
 
1042
                # the bzrdir for this tree
 
1043
                if transport_base_dir == f:
 
1044
                    continue
 
1045
 
 
1046
                # we know that from_dir_relpath and from_dir_abspath never end in a slash
 
1047
                # and 'f' doesn't begin with one, we can do a string op, rather
 
1048
                # than the checks of pathjoin(), all relative paths will have an extra slash
 
1049
                # at the beginning
 
1050
                fp = from_dir_relpath + '/' + f
 
1051
 
 
1052
                # absolute path
 
1053
                fap = from_dir_abspath + '/' + f
 
1054
                
 
1055
                f_ie = inv.get_child(from_dir_id, f)
 
1056
                if f_ie:
 
1057
                    c = 'V'
 
1058
                elif self.is_ignored(fp[1:]):
 
1059
                    c = 'I'
 
1060
                else:
 
1061
                    # we may not have found this file, because of a unicode issue
 
1062
                    f_norm, can_access = osutils.normalized_filename(f)
 
1063
                    if f == f_norm or not can_access:
 
1064
                        # No change, so treat this file normally
 
1065
                        c = '?'
 
1066
                    else:
 
1067
                        # this file can be accessed by a normalized path
 
1068
                        # check again if it is versioned
 
1069
                        # these lines are repeated here for performance
 
1070
                        f = f_norm
 
1071
                        fp = from_dir_relpath + '/' + f
 
1072
                        fap = from_dir_abspath + '/' + f
 
1073
                        f_ie = inv.get_child(from_dir_id, f)
 
1074
                        if f_ie:
 
1075
                            c = 'V'
 
1076
                        elif self.is_ignored(fp[1:]):
 
1077
                            c = 'I'
 
1078
                        else:
 
1079
                            c = '?'
 
1080
 
 
1081
                fk = file_kind(fap)
 
1082
 
 
1083
                # make a last minute entry
 
1084
                if f_ie:
 
1085
                    yield fp[1:], c, fk, f_ie.file_id, f_ie
 
1086
                else:
 
1087
                    try:
 
1088
                        yield fp[1:], c, fk, None, fk_entries[fk]()
 
1089
                    except KeyError:
 
1090
                        yield fp[1:], c, fk, None, TreeEntry()
 
1091
                    continue
 
1092
                
 
1093
                if fk != 'directory':
 
1094
                    continue
 
1095
 
 
1096
                # But do this child first
 
1097
                new_children = os.listdir(fap)
 
1098
                new_children.sort()
 
1099
                new_children = collections.deque(new_children)
 
1100
                stack.append((f_ie.file_id, fp, fap, new_children))
 
1101
                # Break out of inner loop,
 
1102
                # so that we start outer loop with child
 
1103
                break
 
1104
            else:
 
1105
                # if we finished all children, pop it off the stack
 
1106
                stack.pop()
 
1107
 
 
1108
    @needs_tree_write_lock
 
1109
    def move(self, from_paths, to_dir=None, after=False, **kwargs):
924
1110
        """Rename files.
925
1111
 
926
 
        to_dir must be known to the working tree.
 
1112
        to_dir must exist in the inventory.
927
1113
 
928
1114
        If to_dir exists and is a directory, the files are moved into
929
 
        it, keeping their old names.
 
1115
        it, keeping their old names.  
930
1116
 
931
1117
        Note that to_dir is only the last component of the new name;
932
1118
        this doesn't change the directory.
935
1121
        independently.
936
1122
 
937
1123
        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.
 
1124
        inventory. The second mode only updates the inventory without
 
1125
        touching the file on the filesystem. This is the new mode introduced
 
1126
        in version 0.15.
940
1127
 
941
1128
        move uses the second mode if 'after == True' and the target is not
942
1129
        versioned but present in the working tree.
954
1141
        This returns a list of (from_path, to_path) pairs for each
955
1142
        entry that is moved.
956
1143
        """
957
 
        raise NotImplementedError(self.move)
 
1144
        rename_entries = []
 
1145
        rename_tuples = []
 
1146
 
 
1147
        # check for deprecated use of signature
 
1148
        if to_dir is None:
 
1149
            to_dir = kwargs.get('to_name', None)
 
1150
            if to_dir is None:
 
1151
                raise TypeError('You must supply a target directory')
 
1152
            else:
 
1153
                symbol_versioning.warn('The parameter to_name was deprecated'
 
1154
                                       ' in version 0.13. Use to_dir instead',
 
1155
                                       DeprecationWarning)
 
1156
 
 
1157
        # check destination directory
 
1158
        assert not isinstance(from_paths, basestring)
 
1159
        inv = self.inventory
 
1160
        to_abs = self.abspath(to_dir)
 
1161
        if not isdir(to_abs):
 
1162
            raise errors.BzrMoveFailedError('',to_dir,
 
1163
                errors.NotADirectory(to_abs))
 
1164
        if not self.has_filename(to_dir):
 
1165
            raise errors.BzrMoveFailedError('',to_dir,
 
1166
                errors.NotInWorkingDirectory(to_dir))
 
1167
        to_dir_id = inv.path2id(to_dir)
 
1168
        if to_dir_id is None:
 
1169
            raise errors.BzrMoveFailedError('',to_dir,
 
1170
                errors.NotVersionedError(path=str(to_dir)))
 
1171
 
 
1172
        to_dir_ie = inv[to_dir_id]
 
1173
        if to_dir_ie.kind != 'directory':
 
1174
            raise errors.BzrMoveFailedError('',to_dir,
 
1175
                errors.NotADirectory(to_abs))
 
1176
 
 
1177
        # create rename entries and tuples
 
1178
        for from_rel in from_paths:
 
1179
            from_tail = splitpath(from_rel)[-1]
 
1180
            from_id = inv.path2id(from_rel)
 
1181
            if from_id is None:
 
1182
                raise errors.BzrMoveFailedError(from_rel,to_dir,
 
1183
                    errors.NotVersionedError(path=str(from_rel)))
 
1184
 
 
1185
            from_entry = inv[from_id]
 
1186
            from_parent_id = from_entry.parent_id
 
1187
            to_rel = pathjoin(to_dir, from_tail)
 
1188
            rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
 
1189
                                         from_id=from_id,
 
1190
                                         from_tail=from_tail,
 
1191
                                         from_parent_id=from_parent_id,
 
1192
                                         to_rel=to_rel, to_tail=from_tail,
 
1193
                                         to_parent_id=to_dir_id)
 
1194
            rename_entries.append(rename_entry)
 
1195
            rename_tuples.append((from_rel, to_rel))
 
1196
 
 
1197
        # determine which move mode to use. checks also for movability
 
1198
        rename_entries = self._determine_mv_mode(rename_entries, after)
 
1199
 
 
1200
        original_modified = self._inventory_is_modified
 
1201
        try:
 
1202
            if len(from_paths):
 
1203
                self._inventory_is_modified = True
 
1204
            self._move(rename_entries)
 
1205
        except:
 
1206
            # restore the inventory on error
 
1207
            self._inventory_is_modified = original_modified
 
1208
            raise
 
1209
        self._write_inventory(inv)
 
1210
        return rename_tuples
 
1211
 
 
1212
    def _determine_mv_mode(self, rename_entries, after=False):
 
1213
        """Determines for each from-to pair if both inventory and working tree
 
1214
        or only the inventory has to be changed.
 
1215
 
 
1216
        Also does basic plausability tests.
 
1217
        """
 
1218
        inv = self.inventory
 
1219
 
 
1220
        for rename_entry in rename_entries:
 
1221
            # store to local variables for easier reference
 
1222
            from_rel = rename_entry.from_rel
 
1223
            from_id = rename_entry.from_id
 
1224
            to_rel = rename_entry.to_rel
 
1225
            to_id = inv.path2id(to_rel)
 
1226
            only_change_inv = False
 
1227
 
 
1228
            # check the inventory for source and destination
 
1229
            if from_id is None:
 
1230
                raise errors.BzrMoveFailedError(from_rel,to_rel,
 
1231
                    errors.NotVersionedError(path=str(from_rel)))
 
1232
            if to_id is not None:
 
1233
                raise errors.BzrMoveFailedError(from_rel,to_rel,
 
1234
                    errors.AlreadyVersionedError(path=str(to_rel)))
 
1235
 
 
1236
            # try to determine the mode for rename (only change inv or change
 
1237
            # inv and file system)
 
1238
            if after:
 
1239
                if not self.has_filename(to_rel):
 
1240
                    raise errors.BzrMoveFailedError(from_id,to_rel,
 
1241
                        errors.NoSuchFile(path=str(to_rel),
 
1242
                        extra="New file has not been created yet"))
 
1243
                only_change_inv = True
 
1244
            elif not self.has_filename(from_rel) and self.has_filename(to_rel):
 
1245
                only_change_inv = True
 
1246
            elif self.has_filename(from_rel) and not self.has_filename(to_rel):
 
1247
                only_change_inv = False
 
1248
            else:
 
1249
                # something is wrong, so lets determine what exactly
 
1250
                if not self.has_filename(from_rel) and \
 
1251
                   not self.has_filename(to_rel):
 
1252
                    raise errors.BzrRenameFailedError(from_rel,to_rel,
 
1253
                        errors.PathsDoNotExist(paths=(str(from_rel),
 
1254
                        str(to_rel))))
 
1255
                else:
 
1256
                    raise errors.RenameFailedFilesExist(from_rel, to_rel,
 
1257
                        extra="(Use --after to update the Bazaar id)")
 
1258
            rename_entry.only_change_inv = only_change_inv
 
1259
        return rename_entries
 
1260
 
 
1261
    def _move(self, rename_entries):
 
1262
        """Moves a list of files.
 
1263
 
 
1264
        Depending on the value of the flag 'only_change_inv', the
 
1265
        file will be moved on the file system or not.
 
1266
        """
 
1267
        inv = self.inventory
 
1268
        moved = []
 
1269
 
 
1270
        for entry in rename_entries:
 
1271
            try:
 
1272
                self._move_entry(entry)
 
1273
            except:
 
1274
                self._rollback_move(moved)
 
1275
                raise
 
1276
            moved.append(entry)
 
1277
 
 
1278
    def _rollback_move(self, moved):
 
1279
        """Try to rollback a previous move in case of an filesystem error."""
 
1280
        inv = self.inventory
 
1281
        for entry in moved:
 
1282
            try:
 
1283
                self._move_entry(_RenameEntry(entry.to_rel, entry.from_id,
 
1284
                    entry.to_tail, entry.to_parent_id, entry.from_rel,
 
1285
                    entry.from_tail, entry.from_parent_id,
 
1286
                    entry.only_change_inv))
 
1287
            except errors.BzrMoveFailedError, e:
 
1288
                raise errors.BzrMoveFailedError( '', '', "Rollback failed."
 
1289
                        " The working tree is in an inconsistent state."
 
1290
                        " Please consider doing a 'bzr revert'."
 
1291
                        " Error message is: %s" % e)
 
1292
 
 
1293
    def _move_entry(self, entry):
 
1294
        inv = self.inventory
 
1295
        from_rel_abs = self.abspath(entry.from_rel)
 
1296
        to_rel_abs = self.abspath(entry.to_rel)
 
1297
        if from_rel_abs == to_rel_abs:
 
1298
            raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
 
1299
                "Source and target are identical.")
 
1300
 
 
1301
        if not entry.only_change_inv:
 
1302
            try:
 
1303
                osutils.rename(from_rel_abs, to_rel_abs)
 
1304
            except OSError, e:
 
1305
                raise errors.BzrMoveFailedError(entry.from_rel,
 
1306
                    entry.to_rel, e[1])
 
1307
        inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
958
1308
 
959
1309
    @needs_tree_write_lock
960
1310
    def rename_one(self, from_rel, to_rel, after=False):
964
1314
 
965
1315
        rename_one has several 'modes' to work. First, it can rename a physical
966
1316
        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.
 
1317
        only change the file_id without touching any physical file. This is
 
1318
        the new mode introduced in version 0.15.
968
1319
 
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.
 
1320
        rename_one uses the second mode if 'after == True' and 'to_rel' is not
 
1321
        versioned but present in the working tree.
971
1322
 
972
1323
        rename_one uses the second mode if 'after == False' and 'from_rel' is
973
1324
        versioned but no longer in the working tree, and 'to_rel' is not
979
1330
 
980
1331
        Everything else results in an error.
981
1332
        """
982
 
        raise NotImplementedError(self.rename_one)
 
1333
        inv = self.inventory
 
1334
        rename_entries = []
 
1335
 
 
1336
        # create rename entries and tuples
 
1337
        from_tail = splitpath(from_rel)[-1]
 
1338
        from_id = inv.path2id(from_rel)
 
1339
        if from_id is None:
 
1340
            raise errors.BzrRenameFailedError(from_rel,to_rel,
 
1341
                errors.NotVersionedError(path=str(from_rel)))
 
1342
        from_entry = inv[from_id]
 
1343
        from_parent_id = from_entry.parent_id
 
1344
        to_dir, to_tail = os.path.split(to_rel)
 
1345
        to_dir_id = inv.path2id(to_dir)
 
1346
        rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
 
1347
                                     from_id=from_id,
 
1348
                                     from_tail=from_tail,
 
1349
                                     from_parent_id=from_parent_id,
 
1350
                                     to_rel=to_rel, to_tail=to_tail,
 
1351
                                     to_parent_id=to_dir_id)
 
1352
        rename_entries.append(rename_entry)
 
1353
 
 
1354
        # determine which move mode to use. checks also for movability
 
1355
        rename_entries = self._determine_mv_mode(rename_entries, after)
 
1356
 
 
1357
        # check if the target changed directory and if the target directory is
 
1358
        # versioned
 
1359
        if to_dir_id is None:
 
1360
            raise errors.BzrMoveFailedError(from_rel,to_rel,
 
1361
                errors.NotVersionedError(path=str(to_dir)))
 
1362
 
 
1363
        # all checks done. now we can continue with our actual work
 
1364
        mutter('rename_one:\n'
 
1365
               '  from_id   {%s}\n'
 
1366
               '  from_rel: %r\n'
 
1367
               '  to_rel:   %r\n'
 
1368
               '  to_dir    %r\n'
 
1369
               '  to_dir_id {%s}\n',
 
1370
               from_id, from_rel, to_rel, to_dir, to_dir_id)
 
1371
 
 
1372
        self._move(rename_entries)
 
1373
        self._write_inventory(inv)
 
1374
 
 
1375
    class _RenameEntry(object):
 
1376
        def __init__(self, from_rel, from_id, from_tail, from_parent_id,
 
1377
                     to_rel, to_tail, to_parent_id, only_change_inv=False):
 
1378
            self.from_rel = from_rel
 
1379
            self.from_id = from_id
 
1380
            self.from_tail = from_tail
 
1381
            self.from_parent_id = from_parent_id
 
1382
            self.to_rel = to_rel
 
1383
            self.to_tail = to_tail
 
1384
            self.to_parent_id = to_parent_id
 
1385
            self.only_change_inv = only_change_inv
983
1386
 
984
1387
    @needs_read_lock
985
1388
    def unknowns(self):
988
1391
        These are files in the working directory that are not versioned or
989
1392
        control files or ignored.
990
1393
        """
991
 
        # force the extras method to be fully executed before returning, to
 
1394
        # force the extras method to be fully executed before returning, to 
992
1395
        # prevent race conditions with the lock
993
1396
        return iter(
994
1397
            [subp for subp in self.extras() if not self.is_ignored(subp)])
995
1398
 
 
1399
    @needs_tree_write_lock
996
1400
    def unversion(self, file_ids):
997
1401
        """Remove the file ids in file_ids from the current versioned set.
998
1402
 
1002
1406
        :param file_ids: The file ids to stop versioning.
1003
1407
        :raises: NoSuchId if any fileid is not currently versioned.
1004
1408
        """
1005
 
        raise NotImplementedError(self.unversion)
 
1409
        for file_id in file_ids:
 
1410
            file_id = osutils.safe_file_id(file_id)
 
1411
            if self._inventory.has_id(file_id):
 
1412
                self._inventory.remove_recursive_id(file_id)
 
1413
            else:
 
1414
                raise errors.NoSuchId(self, file_id)
 
1415
        if len(file_ids):
 
1416
            # in the future this should just set a dirty bit to wait for the 
 
1417
            # final unlock. However, until all methods of workingtree start
 
1418
            # with the current in -memory inventory rather than triggering 
 
1419
            # a read, it is more complex - we need to teach read_inventory
 
1420
            # to know when to read, and when to not read first... and possibly
 
1421
            # to save first when the in memory one may be corrupted.
 
1422
            # so for now, we just only write it if it is indeed dirty.
 
1423
            # - RBC 20060907
 
1424
            self._write_inventory(self._inventory)
 
1425
    
 
1426
    @deprecated_method(zero_eight)
 
1427
    def iter_conflicts(self):
 
1428
        """List all files in the tree that have text or content conflicts.
 
1429
        DEPRECATED.  Use conflicts instead."""
 
1430
        return self._iter_conflicts()
 
1431
 
 
1432
    def _iter_conflicts(self):
 
1433
        conflicted = set()
 
1434
        for info in self.list_files():
 
1435
            path = info[0]
 
1436
            stem = get_conflicted_stem(path)
 
1437
            if stem is None:
 
1438
                continue
 
1439
            if stem not in conflicted:
 
1440
                conflicted.add(stem)
 
1441
                yield stem
1006
1442
 
1007
1443
    @needs_write_lock
1008
1444
    def pull(self, source, overwrite=False, stop_revision=None,
1009
 
             change_reporter=None, possible_transports=None, local=False,
1010
 
             show_base=False):
 
1445
             change_reporter=None):
 
1446
        top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1011
1447
        source.lock_read()
1012
1448
        try:
 
1449
            pp = ProgressPhase("Pull phase", 2, top_pb)
 
1450
            pp.next_phase()
1013
1451
            old_revision_info = self.branch.last_revision_info()
1014
1452
            basis_tree = self.basis_tree()
1015
 
            count = self.branch.pull(source, overwrite, stop_revision,
1016
 
                                     possible_transports=possible_transports,
1017
 
                                     local=local)
 
1453
            count = self.branch.pull(source, overwrite, stop_revision)
1018
1454
            new_revision_info = self.branch.last_revision_info()
1019
1455
            if new_revision_info != old_revision_info:
 
1456
                pp.next_phase()
1020
1457
                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)
 
1458
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
1026
1459
                basis_tree.lock_read()
1027
1460
                try:
1028
1461
                    new_basis_tree = self.branch.basis_tree()
1031
1464
                                new_basis_tree,
1032
1465
                                basis_tree,
1033
1466
                                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)
 
1467
                                pb=pb,
 
1468
                                change_reporter=change_reporter)
 
1469
                    if (basis_tree.inventory.root is None and
 
1470
                        new_basis_tree.inventory.root is not None):
 
1471
                        self.set_root_id(new_basis_tree.inventory.root.file_id)
1041
1472
                finally:
 
1473
                    pb.finished()
1042
1474
                    basis_tree.unlock()
1043
1475
                # TODO - dedup parents list with things merged by pull ?
1044
1476
                # reuse the revisiontree we merged against to set the new
1045
1477
                # tree data.
1046
1478
                parent_trees = [(self.branch.last_revision(), new_basis_tree)]
1047
 
                # we have to pull the merge trees out again, because
1048
 
                # merge_inner has set the ids. - this corner is not yet
 
1479
                # we have to pull the merge trees out again, because 
 
1480
                # merge_inner has set the ids. - this corner is not yet 
1049
1481
                # layered well enough to prevent double handling.
1050
1482
                # XXX TODO: Fix the double handling: telling the tree about
1051
1483
                # the already known parent data is wasteful.
1057
1489
            return count
1058
1490
        finally:
1059
1491
            source.unlock()
 
1492
            top_pb.finished()
1060
1493
 
1061
1494
    @needs_write_lock
1062
1495
    def put_file_bytes_non_atomic(self, file_id, bytes):
1063
1496
        """See MutableTree.put_file_bytes_non_atomic."""
 
1497
        file_id = osutils.safe_file_id(file_id)
1064
1498
        stream = file(self.id2abspath(file_id), 'wb')
1065
1499
        try:
1066
1500
            stream.write(bytes)
1078
1512
        Currently returned depth-first, sorted by name within directories.
1079
1513
        This is the same order used by 'osutils.walkdirs'.
1080
1514
        """
1081
 
        raise NotImplementedError(self.extras)
 
1515
        ## TODO: Work from given directory downwards
 
1516
        for path, dir_entry in self.inventory.directories():
 
1517
            # mutter("search for unknowns in %r", path)
 
1518
            dirabs = self.abspath(path)
 
1519
            if not isdir(dirabs):
 
1520
                # e.g. directory deleted
 
1521
                continue
 
1522
 
 
1523
            fl = []
 
1524
            for subf in os.listdir(dirabs):
 
1525
                if subf == '.bzr':
 
1526
                    continue
 
1527
                if subf not in dir_entry.children:
 
1528
                    subf_norm, can_access = osutils.normalized_filename(subf)
 
1529
                    if subf_norm != subf and can_access:
 
1530
                        if subf_norm not in dir_entry.children:
 
1531
                            fl.append(subf_norm)
 
1532
                    else:
 
1533
                        fl.append(subf)
 
1534
            
 
1535
            fl.sort()
 
1536
            for subf in fl:
 
1537
                subp = pathjoin(path, subf)
 
1538
                yield subp
1082
1539
 
1083
1540
    def ignored_files(self):
1084
1541
        """Yield list of PATH, IGNORE_PATTERN"""
1096
1553
        if ignoreset is not None:
1097
1554
            return ignoreset
1098
1555
 
1099
 
        ignore_globs = set()
 
1556
        ignore_globs = set(bzrlib.DEFAULT_IGNORE)
1100
1557
        ignore_globs.update(ignores.get_runtime_ignores())
1101
1558
        ignore_globs.update(ignores.get_user_ignores())
1102
1559
        if self.has_filename(bzrlib.IGNORE_FILENAME):
1117
1574
        r"""Check whether the filename matches an ignore pattern.
1118
1575
 
1119
1576
        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.
 
1577
        others match against only the last component.
1123
1578
 
1124
1579
        If the file is ignored, returns the pattern which caused it to
1125
1580
        be ignored, otherwise None.  So this can simply be used as a
1126
1581
        boolean if desired."""
1127
1582
        if getattr(self, '_ignoreglobster', None) is None:
1128
 
            self._ignoreglobster = globbing.ExceptionGlobster(self.get_ignore_list())
 
1583
            self._ignoreglobster = globbing.Globster(self.get_ignore_list())
1129
1584
        return self._ignoreglobster.match(filename)
1130
1585
 
1131
1586
    def kind(self, file_id):
1132
1587
        return file_kind(self.id2abspath(file_id))
1133
1588
 
1134
 
    def stored_kind(self, file_id):
1135
 
        """See Tree.stored_kind"""
1136
 
        raise NotImplementedError(self.stored_kind)
1137
 
 
1138
1589
    def _comparison_data(self, entry, path):
1139
1590
        abspath = self.abspath(path)
1140
1591
        try:
1150
1601
            mode = stat_value.st_mode
1151
1602
            kind = osutils.file_kind_from_stat_mode(mode)
1152
1603
            if not supports_executable():
1153
 
                executable = entry is not None and entry.executable
 
1604
                executable = entry.executable
1154
1605
            else:
1155
1606
                executable = bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
1156
1607
        return kind, executable, stat_value
1171
1622
    @needs_read_lock
1172
1623
    def _last_revision(self):
1173
1624
        """helper for get_parent_ids."""
1174
 
        return _mod_revision.ensure_null(self.branch.last_revision())
 
1625
        return self.branch.last_revision()
1175
1626
 
1176
1627
    def is_locked(self):
1177
1628
        return self._control_files.is_locked()
1181
1632
            raise errors.ObjectNotLocked(self)
1182
1633
 
1183
1634
    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
 
        """
 
1635
        """See Branch.lock_read, and WorkingTree.unlock."""
1190
1636
        if not self.is_locked():
1191
1637
            self._reset_data()
1192
1638
        self.branch.lock_read()
1193
1639
        try:
1194
 
            self._control_files.lock_read()
1195
 
            return LogicalLockResult(self.unlock)
 
1640
            return self._control_files.lock_read()
1196
1641
        except:
1197
1642
            self.branch.unlock()
1198
1643
            raise
1199
1644
 
1200
1645
    def lock_tree_write(self):
1201
 
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
1202
 
 
1203
 
        :return: A bzrlib.lock.LogicalLockResult.
1204
 
        """
 
1646
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
1205
1647
        if not self.is_locked():
1206
1648
            self._reset_data()
1207
1649
        self.branch.lock_read()
1208
1650
        try:
1209
 
            self._control_files.lock_write()
1210
 
            return LogicalLockResult(self.unlock)
 
1651
            return self._control_files.lock_write()
1211
1652
        except:
1212
1653
            self.branch.unlock()
1213
1654
            raise
1214
1655
 
1215
1656
    def lock_write(self):
1216
 
        """See MutableTree.lock_write, and WorkingTree.unlock.
1217
 
 
1218
 
        :return: A bzrlib.lock.LogicalLockResult.
1219
 
        """
 
1657
        """See MutableTree.lock_write, and WorkingTree.unlock."""
1220
1658
        if not self.is_locked():
1221
1659
            self._reset_data()
1222
1660
        self.branch.lock_write()
1223
1661
        try:
1224
 
            self._control_files.lock_write()
1225
 
            return LogicalLockResult(self.unlock)
 
1662
            return self._control_files.lock_write()
1226
1663
        except:
1227
1664
            self.branch.unlock()
1228
1665
            raise
1230
1667
    def get_physical_lock_status(self):
1231
1668
        return self._control_files.get_physical_lock_status()
1232
1669
 
 
1670
    def _basis_inventory_name(self):
 
1671
        return 'basis-inventory-cache'
 
1672
 
1233
1673
    def _reset_data(self):
1234
1674
        """Reset transient data that cannot be revalidated."""
1235
 
        raise NotImplementedError(self._reset_data)
 
1675
        self._inventory_is_modified = False
 
1676
        result = self._deserialize(self._control_files.get('inventory'))
 
1677
        self._set_inventory(result, dirty=False)
1236
1678
 
 
1679
    @needs_tree_write_lock
1237
1680
    def set_last_revision(self, new_revision):
1238
1681
        """Change the last revision in the working tree."""
1239
 
        raise NotImplementedError(self.set_last_revision)
 
1682
        new_revision = osutils.safe_revision_id(new_revision)
 
1683
        if self._change_last_revision(new_revision):
 
1684
            self._cache_basis_inventory(new_revision)
1240
1685
 
1241
1686
    def _change_last_revision(self, new_revision):
1242
1687
        """Template method part of set_last_revision to perform the change.
1243
 
 
 
1688
        
1244
1689
        This is used to allow WorkingTree3 instances to not affect branch
1245
1690
        when their last revision is set.
1246
1691
        """
1247
 
        if _mod_revision.is_null(new_revision):
1248
 
            self.branch.set_last_revision_info(0, new_revision)
 
1692
        if new_revision is None:
 
1693
            self.branch.set_revision_history([])
1249
1694
            return False
1250
 
        _mod_revision.check_not_reserved_id(new_revision)
1251
1695
        try:
1252
1696
            self.branch.generate_revision_history(new_revision)
1253
1697
        except errors.NoSuchRevision:
1254
1698
            # not present in the repo - dont try to set it deeper than the tip
1255
 
            self.branch._set_revision_history([new_revision])
 
1699
            self.branch.set_revision_history([new_revision])
1256
1700
        return True
1257
1701
 
 
1702
    def _write_basis_inventory(self, xml):
 
1703
        """Write the basis inventory XML to the basis-inventory file"""
 
1704
        assert isinstance(xml, str), 'serialised xml must be bytestring.'
 
1705
        path = self._basis_inventory_name()
 
1706
        sio = StringIO(xml)
 
1707
        self._control_files.put(path, sio)
 
1708
 
 
1709
    def _create_basis_xml_from_inventory(self, revision_id, inventory):
 
1710
        """Create the text that will be saved in basis-inventory"""
 
1711
        # TODO: jam 20070209 This should be redundant, as the revision_id
 
1712
        #       as all callers should have already converted the revision_id to
 
1713
        #       utf8
 
1714
        inventory.revision_id = osutils.safe_revision_id(revision_id)
 
1715
        return xml7.serializer_v7.write_inventory_to_string(inventory)
 
1716
 
 
1717
    def _cache_basis_inventory(self, new_revision):
 
1718
        """Cache new_revision as the basis inventory."""
 
1719
        # TODO: this should allow the ready-to-use inventory to be passed in,
 
1720
        # as commit already has that ready-to-use [while the format is the
 
1721
        # same, that is].
 
1722
        try:
 
1723
            # this double handles the inventory - unpack and repack - 
 
1724
            # but is easier to understand. We can/should put a conditional
 
1725
            # in here based on whether the inventory is in the latest format
 
1726
            # - perhaps we should repack all inventories on a repository
 
1727
            # upgrade ?
 
1728
            # the fast path is to copy the raw xml from the repository. If the
 
1729
            # xml contains 'revision_id="', then we assume the right 
 
1730
            # revision_id is set. We must check for this full string, because a
 
1731
            # root node id can legitimately look like 'revision_id' but cannot
 
1732
            # contain a '"'.
 
1733
            xml = self.branch.repository.get_inventory_xml(new_revision)
 
1734
            firstline = xml.split('\n', 1)[0]
 
1735
            if (not 'revision_id="' in firstline or 
 
1736
                'format="7"' not in firstline):
 
1737
                inv = self.branch.repository.deserialise_inventory(
 
1738
                    new_revision, xml)
 
1739
                xml = self._create_basis_xml_from_inventory(new_revision, inv)
 
1740
            self._write_basis_inventory(xml)
 
1741
        except (errors.NoSuchRevision, errors.RevisionNotPresent):
 
1742
            pass
 
1743
 
 
1744
    def read_basis_inventory(self):
 
1745
        """Read the cached basis inventory."""
 
1746
        path = self._basis_inventory_name()
 
1747
        return self._control_files.get(path).read()
 
1748
        
 
1749
    @needs_read_lock
 
1750
    def read_working_inventory(self):
 
1751
        """Read the working inventory.
 
1752
        
 
1753
        :raises errors.InventoryModified: read_working_inventory will fail
 
1754
            when the current in memory inventory has been modified.
 
1755
        """
 
1756
        # conceptually this should be an implementation detail of the tree. 
 
1757
        # XXX: Deprecate this.
 
1758
        # ElementTree does its own conversion from UTF-8, so open in
 
1759
        # binary.
 
1760
        if self._inventory_is_modified:
 
1761
            raise errors.InventoryModified(self)
 
1762
        result = self._deserialize(self._control_files.get('inventory'))
 
1763
        self._set_inventory(result, dirty=False)
 
1764
        return result
 
1765
 
1258
1766
    @needs_tree_write_lock
1259
 
    def remove(self, files, verbose=False, to_file=None, keep_files=True,
1260
 
        force=False):
1261
 
        """Remove nominated files from the working tree metadata.
1262
 
 
1263
 
        :files: File paths relative to the basedir.
1264
 
        :keep_files: If true, the files will also be kept.
1265
 
        :force: Delete files and directories, even if they are changed and
1266
 
            even if the directories are not empty.
 
1767
    def remove(self, files, verbose=False, to_file=None):
 
1768
        """Remove nominated files from the working inventory..
 
1769
 
 
1770
        This does not remove their text.  This does not run on XXX on what? RBC
 
1771
 
 
1772
        TODO: Refuse to remove modified files unless --force is given?
 
1773
 
 
1774
        TODO: Do something useful with directories.
 
1775
 
 
1776
        TODO: Should this remove the text or not?  Tough call; not
 
1777
        removing may be useful and the user can just use use rm, and
 
1778
        is the opposite of add.  Removing it is consistent with most
 
1779
        other tools.  Maybe an option.
1267
1780
        """
 
1781
        ## TODO: Normalize names
 
1782
        ## TODO: Remove nested loops; better scalability
1268
1783
        if isinstance(files, basestring):
1269
1784
            files = [files]
1270
1785
 
1271
 
        inv_delta = []
1272
 
 
1273
 
        all_files = set() # specified and nested files 
1274
 
        unknown_nested_files=set()
1275
 
        if to_file is None:
1276
 
            to_file = sys.stdout
1277
 
 
1278
 
        files_to_backup = []
1279
 
 
1280
 
        def recurse_directory_to_add_files(directory):
1281
 
            # Recurse directory and add all files
1282
 
            # so we can check if they have changed.
1283
 
            for parent_info, file_infos in self.walkdirs(directory):
1284
 
                for relpath, basename, kind, lstat, fileid, kind in file_infos:
1285
 
                    # Is it versioned or ignored?
1286
 
                    if self.path2id(relpath):
1287
 
                        # Add nested content for deletion.
1288
 
                        all_files.add(relpath)
1289
 
                    else:
1290
 
                        # Files which are not versioned
1291
 
                        # should be treated as unknown.
1292
 
                        files_to_backup.append(relpath)
1293
 
 
1294
 
        for filename in files:
1295
 
            # Get file name into canonical form.
1296
 
            abspath = self.abspath(filename)
1297
 
            filename = self.relpath(abspath)
1298
 
            if len(filename) > 0:
1299
 
                all_files.add(filename)
1300
 
                recurse_directory_to_add_files(filename)
1301
 
 
1302
 
        files = list(all_files)
1303
 
 
1304
 
        if len(files) == 0:
1305
 
            return # nothing to do
1306
 
 
1307
 
        # Sort needed to first handle directory content before the directory
1308
 
        files.sort(reverse=True)
1309
 
 
1310
 
        # Bail out if we are going to delete files we shouldn't
1311
 
        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])
1324
 
 
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)
1330
 
 
1331
 
        # Build inv_delta and delete files where applicable,
1332
 
        # do this before any modifications to meta data.
 
1786
        inv = self.inventory
 
1787
 
 
1788
        # do this before any modifications
1333
1789
        for f in files:
1334
 
            fid = self.path2id(f)
1335
 
            message = None
 
1790
            fid = inv.path2id(f)
1336
1791
            if not fid:
1337
 
                message = "%s is not versioned." % (f,)
 
1792
                note("%s is not versioned."%f)
1338
1793
            else:
1339
1794
                if verbose:
1340
 
                    # having removed it, it must be either ignored or unknown
 
1795
                    # having remove it, it must be either ignored or unknown
1341
1796
                    if self.is_ignored(f):
1342
1797
                        new_status = 'I'
1343
1798
                    else:
1344
1799
                        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')
1348
 
                # Unversion file
1349
 
                inv_delta.append((f, None, fid, None))
1350
 
                message = "removed %s" % (f,)
1351
 
 
1352
 
            if not keep_files:
1353
 
                abs_path = self.abspath(f)
1354
 
                if osutils.lexists(abs_path):
1355
 
                    if (osutils.isdir(abs_path) and
1356
 
                        len(os.listdir(abs_path)) > 0):
1357
 
                        if force:
1358
 
                            osutils.rmtree(abs_path)
1359
 
                            message = "deleted %s" % (f,)
1360
 
                        else:
1361
 
                            message = backup(f)
1362
 
                    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,)
1368
 
                elif message is not None:
1369
 
                    # Only care if we haven't done anything yet.
1370
 
                    message = "%s does not exist." % (f,)
1371
 
 
1372
 
            # Print only one message (if any) per file.
1373
 
            if message is not None:
1374
 
                note(message)
1375
 
        self.apply_inventory_delta(inv_delta)
 
1800
                    textui.show_status(new_status, inv[fid].kind, f,
 
1801
                                       to_file=to_file)
 
1802
                del inv[fid]
 
1803
 
 
1804
        self._write_inventory(inv)
1376
1805
 
1377
1806
    @needs_tree_write_lock
1378
 
    def revert(self, filenames=None, old_tree=None, backups=True,
1379
 
               pb=None, report_changes=False):
 
1807
    def revert(self, filenames, old_tree=None, backups=True, 
 
1808
               pb=DummyProgress(), report_changes=False):
1380
1809
        from bzrlib.conflicts import resolve
1381
1810
        if old_tree is None:
1382
 
            basis_tree = self.basis_tree()
1383
 
            basis_tree.lock_read()
1384
 
            old_tree = basis_tree
 
1811
            old_tree = self.basis_tree()
 
1812
        conflicts = transform.revert(self, old_tree, filenames, backups, pb,
 
1813
                                     report_changes)
 
1814
        if not len(filenames):
 
1815
            self.set_parent_ids(self.get_parent_ids()[:1])
 
1816
            resolve(self)
1385
1817
        else:
1386
 
            basis_tree = None
1387
 
        try:
1388
 
            conflicts = transform.revert(self, old_tree, filenames, backups, pb,
1389
 
                                         report_changes)
1390
 
            if filenames is None and len(self.get_parent_ids()) > 1:
1391
 
                parent_trees = []
1392
 
                last_revision = self.last_revision()
1393
 
                if last_revision != _mod_revision.NULL_REVISION:
1394
 
                    if basis_tree is None:
1395
 
                        basis_tree = self.basis_tree()
1396
 
                        basis_tree.lock_read()
1397
 
                    parent_trees.append((last_revision, basis_tree))
1398
 
                self.set_parent_trees(parent_trees)
1399
 
                resolve(self)
1400
 
            else:
1401
 
                resolve(self, filenames, ignore_misses=True, recursive=True)
1402
 
        finally:
1403
 
            if basis_tree is not None:
1404
 
                basis_tree.unlock()
 
1818
            resolve(self, filenames, ignore_misses=True)
1405
1819
        return conflicts
1406
1820
 
1407
1821
    def revision_tree(self, revision_id):
1410
1824
        WorkingTree can supply revision_trees for the basis revision only
1411
1825
        because there is only one cached inventory in the bzr directory.
1412
1826
        """
1413
 
        raise NotImplementedError(self.revision_tree)
 
1827
        if revision_id == self.last_revision():
 
1828
            try:
 
1829
                xml = self.read_basis_inventory()
 
1830
            except errors.NoSuchFile:
 
1831
                pass
 
1832
            else:
 
1833
                try:
 
1834
                    inv = xml7.serializer_v7.read_inventory_from_string(xml)
 
1835
                    # dont use the repository revision_tree api because we want
 
1836
                    # to supply the inventory.
 
1837
                    if inv.revision_id == revision_id:
 
1838
                        return revisiontree.RevisionTree(self.branch.repository,
 
1839
                            inv, revision_id)
 
1840
                except errors.BadInventoryFormat:
 
1841
                    pass
 
1842
        # raise if there was no inventory, or if we read the wrong inventory.
 
1843
        raise errors.NoSuchRevisionInTree(self, revision_id)
 
1844
 
 
1845
    # XXX: This method should be deprecated in favour of taking in a proper
 
1846
    # new Inventory object.
 
1847
    @needs_tree_write_lock
 
1848
    def set_inventory(self, new_inventory_list):
 
1849
        from bzrlib.inventory import (Inventory,
 
1850
                                      InventoryDirectory,
 
1851
                                      InventoryEntry,
 
1852
                                      InventoryFile,
 
1853
                                      InventoryLink)
 
1854
        inv = Inventory(self.get_root_id())
 
1855
        for path, file_id, parent, kind in new_inventory_list:
 
1856
            name = os.path.basename(path)
 
1857
            if name == "":
 
1858
                continue
 
1859
            # fixme, there should be a factory function inv,add_?? 
 
1860
            if kind == 'directory':
 
1861
                inv.add(InventoryDirectory(file_id, name, parent))
 
1862
            elif kind == 'file':
 
1863
                inv.add(InventoryFile(file_id, name, parent))
 
1864
            elif kind == 'symlink':
 
1865
                inv.add(InventoryLink(file_id, name, parent))
 
1866
            else:
 
1867
                raise errors.BzrError("unknown kind %r" % kind)
 
1868
        self._write_inventory(inv)
1414
1869
 
1415
1870
    @needs_tree_write_lock
1416
1871
    def set_root_id(self, file_id):
1417
1872
        """Set the root id for this tree."""
1418
 
        # for compatability
 
1873
        # for compatability 
1419
1874
        if file_id is None:
1420
 
            raise ValueError(
1421
 
                'WorkingTree.set_root_id with fileid=None')
1422
 
        file_id = osutils.safe_file_id(file_id)
 
1875
            symbol_versioning.warn(symbol_versioning.zero_twelve
 
1876
                % 'WorkingTree.set_root_id with fileid=None',
 
1877
                DeprecationWarning,
 
1878
                stacklevel=3)
 
1879
            file_id = ROOT_ID
 
1880
        else:
 
1881
            file_id = osutils.safe_file_id(file_id)
1423
1882
        self._set_root_id(file_id)
1424
1883
 
1425
1884
    def _set_root_id(self, file_id):
1426
1885
        """Set the root id for this tree, in a format specific manner.
1427
1886
 
1428
 
        :param file_id: The file id to assign to the root. It must not be
 
1887
        :param file_id: The file id to assign to the root. It must not be 
1429
1888
            present in the current inventory or an error will occur. It must
1430
1889
            not be None, but rather a valid file id.
1431
1890
        """
1432
 
        raise NotImplementedError(self._set_root_id)
 
1891
        inv = self._inventory
 
1892
        orig_root_id = inv.root.file_id
 
1893
        # TODO: it might be nice to exit early if there was nothing
 
1894
        # to do, saving us from trigger a sync on unlock.
 
1895
        self._inventory_is_modified = True
 
1896
        # we preserve the root inventory entry object, but
 
1897
        # unlinkit from the byid index
 
1898
        del inv._byid[inv.root.file_id]
 
1899
        inv.root.file_id = file_id
 
1900
        # and link it into the index with the new changed id.
 
1901
        inv._byid[inv.root.file_id] = inv.root
 
1902
        # and finally update all children to reference the new id.
 
1903
        # XXX: this should be safe to just look at the root.children
 
1904
        # list, not the WHOLE INVENTORY.
 
1905
        for fid in inv:
 
1906
            entry = inv[fid]
 
1907
            if entry.parent_id == orig_root_id:
 
1908
                entry.parent_id = inv.root.file_id
1433
1909
 
1434
1910
    def unlock(self):
1435
1911
        """See Branch.unlock.
1436
 
 
 
1912
        
1437
1913
        WorkingTree locking just uses the Branch locking facilities.
1438
1914
        This is current because all working trees have an embedded branch
1439
1915
        within them. IF in the future, we were to make branch data shareable
1440
 
        between multiple working trees, i.e. via shared storage, then we
 
1916
        between multiple working trees, i.e. via shared storage, then we 
1441
1917
        would probably want to lock both the local tree, and the branch.
1442
1918
        """
1443
1919
        raise NotImplementedError(self.unlock)
1444
1920
 
1445
 
    _marker = object()
1446
 
 
1447
 
    def update(self, change_reporter=None, possible_transports=None,
1448
 
               revision=None, old_tip=_marker, show_base=False):
 
1921
    def update(self):
1449
1922
        """Update a working tree along its branch.
1450
1923
 
1451
1924
        This will update the branch if its bound too, which means we have
1466
1939
        - Restore the wt.basis->wt.state changes.
1467
1940
 
1468
1941
        There isn't a single operation at the moment to do that, so we:
1469
 
 
1470
1942
        - Merge current state -> basis tree of the master w.r.t. the old tree
1471
1943
          basis.
1472
1944
        - 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
1945
        """
1480
 
        if self.branch.get_bound_location() is not None:
 
1946
        if self.branch.get_master_branch() is not None:
1481
1947
            self.lock_write()
1482
 
            update_branch = (old_tip is self._marker)
 
1948
            update_branch = True
1483
1949
        else:
1484
1950
            self.lock_tree_write()
1485
1951
            update_branch = False
1486
1952
        try:
1487
1953
            if update_branch:
1488
 
                old_tip = self.branch.update(possible_transports)
 
1954
                old_tip = self.branch.update()
1489
1955
            else:
1490
 
                if old_tip is self._marker:
1491
 
                    old_tip = None
1492
 
            return self._update_tree(old_tip, change_reporter, revision, show_base)
 
1956
                old_tip = None
 
1957
            return self._update_tree(old_tip)
1493
1958
        finally:
1494
1959
            self.unlock()
1495
1960
 
1496
1961
    @needs_tree_write_lock
1497
 
    def _update_tree(self, old_tip=None, change_reporter=None, revision=None,
1498
 
                     show_base=False):
 
1962
    def _update_tree(self, old_tip=None):
1499
1963
        """Update a tree to the master branch.
1500
1964
 
1501
1965
        :param old_tip: if supplied, the previous tip revision the branch,
1507
1971
        # cant set that until we update the working trees last revision to be
1508
1972
        # one from the new branch, because it will just get absorbed by the
1509
1973
        # parent de-duplication logic.
1510
 
        #
 
1974
        # 
1511
1975
        # We MUST save it even if an error occurs, because otherwise the users
1512
1976
        # local work is unreferenced and will appear to have been lost.
1513
 
        #
1514
 
        nb_conflicts = 0
 
1977
        # 
 
1978
        result = 0
1515
1979
        try:
1516
1980
            last_rev = self.get_parent_ids()[0]
1517
1981
        except IndexError:
1518
 
            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
 
 
 
1982
            last_rev = None
 
1983
        if last_rev != self.branch.last_revision():
 
1984
            # merge tree state up to new branch tip.
1544
1985
            basis = self.basis_tree()
1545
1986
            basis.lock_read()
1546
1987
            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)
 
1988
                to_tree = self.branch.basis_tree()
 
1989
                if basis.inventory.root is None:
 
1990
                    self.set_root_id(to_tree.inventory.root.file_id)
1549
1991
                    self.flush()
 
1992
                result += merge.merge_inner(
 
1993
                                      self.branch,
 
1994
                                      to_tree,
 
1995
                                      basis,
 
1996
                                      this_tree=self)
1550
1997
            finally:
1551
1998
                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
1999
            # TODO - dedup parents list with things merged by pull ?
1565
2000
            # reuse the tree we've updated to to set the basis:
1566
 
            parent_trees = [(revision, to_tree)]
 
2001
            parent_trees = [(self.branch.last_revision(), to_tree)]
1567
2002
            merges = self.get_parent_ids()[1:]
1568
2003
            # Ideally we ask the tree for the trees here, that way the working
1569
 
            # tree can decide whether to give us the entire tree or give us a
 
2004
            # tree can decide whether to give us teh entire tree or give us a
1570
2005
            # lazy initialised tree. dirstate for instance will have the trees
1571
2006
            # in ram already, whereas a last-revision + basis-inventory tree
1572
2007
            # will not, but also does not need them when setting parents.
1573
2008
            for parent in merges:
1574
2009
                parent_trees.append(
1575
2010
                    (parent, self.branch.repository.revision_tree(parent)))
1576
 
            if not _mod_revision.is_null(old_tip):
 
2011
            if old_tip is not None:
1577
2012
                parent_trees.append(
1578
2013
                    (old_tip, self.branch.repository.revision_tree(old_tip)))
1579
2014
            self.set_parent_trees(parent_trees)
1580
2015
            last_rev = parent_trees[0][0]
1581
 
        return nb_conflicts
 
2016
        else:
 
2017
            # the working tree had the same last-revision as the master
 
2018
            # branch did. We may still have pivot local work from the local
 
2019
            # branch into old_tip:
 
2020
            if old_tip is not None:
 
2021
                self.add_parent_tree_id(old_tip)
 
2022
        if old_tip and old_tip != last_rev:
 
2023
            # our last revision was not the prior branch last revision
 
2024
            # and we have converted that last revision to a pending merge.
 
2025
            # base is somewhere between the branch tip now
 
2026
            # and the now pending merge
 
2027
 
 
2028
            # Since we just modified the working tree and inventory, flush out
 
2029
            # the current state, before we modify it again.
 
2030
            # TODO: jam 20070214 WorkingTree3 doesn't require this, dirstate
 
2031
            #       requires it only because TreeTransform directly munges the
 
2032
            #       inventory and calls tree._write_inventory(). Ultimately we
 
2033
            #       should be able to remove this extra flush.
 
2034
            self.flush()
 
2035
            from bzrlib.revision import common_ancestor
 
2036
            try:
 
2037
                base_rev_id = common_ancestor(self.branch.last_revision(),
 
2038
                                              old_tip,
 
2039
                                              self.branch.repository)
 
2040
            except errors.NoCommonAncestor:
 
2041
                base_rev_id = None
 
2042
            base_tree = self.branch.repository.revision_tree(base_rev_id)
 
2043
            other_tree = self.branch.repository.revision_tree(old_tip)
 
2044
            result += merge.merge_inner(
 
2045
                                  self.branch,
 
2046
                                  other_tree,
 
2047
                                  base_tree,
 
2048
                                  this_tree=self)
 
2049
        return result
1582
2050
 
1583
2051
    def _write_hashcache_if_dirty(self):
1584
2052
        """Write out the hashcache if it is dirty."""
1592
2060
                #       warning might be sufficient to let the user know what
1593
2061
                #       is going on.
1594
2062
                mutter('Could not write hashcache for %s\nError: %s',
1595
 
                              self._hashcache.cache_file_name(), e)
 
2063
                       self._hashcache.cache_file_name(), e)
 
2064
 
 
2065
    @needs_tree_write_lock
 
2066
    def _write_inventory(self, inv):
 
2067
        """Write inventory as the current inventory."""
 
2068
        self._set_inventory(inv, dirty=True)
 
2069
        self.flush()
1596
2070
 
1597
2071
    def set_conflicts(self, arg):
1598
2072
        raise errors.UnsupportedOperation(self.set_conflicts, self)
1600
2074
    def add_conflicts(self, arg):
1601
2075
        raise errors.UnsupportedOperation(self.add_conflicts, self)
1602
2076
 
 
2077
    @needs_read_lock
1603
2078
    def conflicts(self):
1604
 
        raise NotImplementedError(self.conflicts)
 
2079
        conflicts = _mod_conflicts.ConflictList()
 
2080
        for conflicted in self._iter_conflicts():
 
2081
            text = True
 
2082
            try:
 
2083
                if file_kind(self.abspath(conflicted)) != "file":
 
2084
                    text = False
 
2085
            except errors.NoSuchFile:
 
2086
                text = False
 
2087
            if text is True:
 
2088
                for suffix in ('.THIS', '.OTHER'):
 
2089
                    try:
 
2090
                        kind = file_kind(self.abspath(conflicted+suffix))
 
2091
                        if kind != "file":
 
2092
                            text = False
 
2093
                    except errors.NoSuchFile:
 
2094
                        text = False
 
2095
                    if text == False:
 
2096
                        break
 
2097
            ctype = {True: 'text conflict', False: 'contents conflict'}[text]
 
2098
            conflicts.append(_mod_conflicts.Conflict.factory(ctype,
 
2099
                             path=conflicted,
 
2100
                             file_id=self.path2id(conflicted)))
 
2101
        return conflicts
1605
2102
 
1606
2103
    def walkdirs(self, prefix=""):
1607
2104
        """Walk the directories of this tree.
1608
2105
 
1609
 
        returns a generator which yields items in the form:
1610
 
                ((curren_directory_path, fileid),
1611
 
                 [(file1_path, file1_name, file1_kind, (lstat), file1_id,
1612
 
                   file1_kind), ... ])
1613
 
 
1614
2106
        This API returns a generator, which is only valid during the current
1615
2107
        tree transaction - within a single lock_read or lock_write duration.
1616
2108
 
1617
 
        If the tree is not locked, it may cause an error to be raised,
1618
 
        depending on the tree implementation.
 
2109
        If the tree is not locked, it may cause an error to be raised, depending
 
2110
        on the tree implementation.
1619
2111
        """
1620
2112
        disk_top = self.abspath(prefix)
1621
2113
        if disk_top.endswith('/'):
1627
2119
            current_disk = disk_iterator.next()
1628
2120
            disk_finished = False
1629
2121
        except OSError, e:
1630
 
            if not (e.errno == errno.ENOENT or
1631
 
                (sys.platform == 'win32' and e.errno == ERROR_PATH_NOT_FOUND)):
 
2122
            if e.errno != errno.ENOENT:
1632
2123
                raise
1633
2124
            current_disk = None
1634
2125
            disk_finished = True
1639
2130
            current_inv = None
1640
2131
            inv_finished = True
1641
2132
        while not inv_finished or not disk_finished:
1642
 
            if current_disk:
1643
 
                ((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
1644
 
                    cur_disk_dir_content) = current_disk
1645
 
            else:
1646
 
                ((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
1647
 
                    cur_disk_dir_content) = ((None, None), None)
1648
2133
            if not disk_finished:
1649
2134
                # strip out .bzr dirs
1650
 
                if (cur_disk_dir_path_from_top[top_strip_len:] == '' and
1651
 
                    len(cur_disk_dir_content) > 0):
1652
 
                    # osutils.walkdirs can be made nicer -
 
2135
                if current_disk[0][1][top_strip_len:] == '':
 
2136
                    # osutils.walkdirs can be made nicer - 
1653
2137
                    # yield the path-from-prefix rather than the pathjoined
1654
2138
                    # value.
1655
 
                    bzrdir_loc = bisect_left(cur_disk_dir_content,
1656
 
                        ('.bzr', '.bzr'))
1657
 
                    if (bzrdir_loc < len(cur_disk_dir_content)
1658
 
                        and self.bzrdir.is_control_filename(
1659
 
                            cur_disk_dir_content[bzrdir_loc][0])):
 
2139
                    bzrdir_loc = bisect_left(current_disk[1], ('.bzr', '.bzr'))
 
2140
                    if current_disk[1][bzrdir_loc][0] == '.bzr':
1660
2141
                        # we dont yield the contents of, or, .bzr itself.
1661
 
                        del cur_disk_dir_content[bzrdir_loc]
 
2142
                        del current_disk[1][bzrdir_loc]
1662
2143
            if inv_finished:
1663
2144
                # everything is unknown
1664
2145
                direction = 1
1666
2147
                # everything is missing
1667
2148
                direction = -1
1668
2149
            else:
1669
 
                direction = cmp(current_inv[0][0], cur_disk_dir_relpath)
 
2150
                direction = cmp(current_inv[0][0], current_disk[0][0])
1670
2151
            if direction > 0:
1671
2152
                # disk is before inventory - unknown
1672
2153
                dirblock = [(relpath, basename, kind, stat, None, None) for
1673
 
                    relpath, basename, kind, stat, top_path in
1674
 
                    cur_disk_dir_content]
1675
 
                yield (cur_disk_dir_relpath, None), dirblock
 
2154
                    relpath, basename, kind, stat, top_path in current_disk[1]]
 
2155
                yield (current_disk[0][0], None), dirblock
1676
2156
                try:
1677
2157
                    current_disk = disk_iterator.next()
1678
2158
                except StopIteration:
1680
2160
            elif direction < 0:
1681
2161
                # inventory is before disk - missing.
1682
2162
                dirblock = [(relpath, basename, 'unknown', None, fileid, kind)
1683
 
                    for relpath, basename, dkind, stat, fileid, kind in
 
2163
                    for relpath, basename, dkind, stat, fileid, kind in 
1684
2164
                    current_inv[1]]
1685
2165
                yield (current_inv[0][0], current_inv[0][1]), dirblock
1686
2166
                try:
1692
2172
                # merge the inventory and disk data together
1693
2173
                dirblock = []
1694
2174
                for relpath, subiterator in itertools.groupby(sorted(
1695
 
                    current_inv[1] + cur_disk_dir_content,
1696
 
                    key=operator.itemgetter(0)), operator.itemgetter(1)):
 
2175
                    current_inv[1] + current_disk[1], key=operator.itemgetter(0)), operator.itemgetter(1)):
1697
2176
                    path_elements = list(subiterator)
1698
2177
                    if len(path_elements) == 2:
1699
2178
                        inv_row, disk_row = path_elements
1725
2204
                    disk_finished = True
1726
2205
 
1727
2206
    def _walkdirs(self, prefix=""):
1728
 
        """Walk the directories of this tree.
1729
 
 
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), ... ])
1736
 
        """
1737
 
        raise NotImplementedError(self._walkdirs)
 
2207
        _directory = 'directory'
 
2208
        # get the root in the inventory
 
2209
        inv = self.inventory
 
2210
        top_id = inv.path2id(prefix)
 
2211
        if top_id is None:
 
2212
            pending = []
 
2213
        else:
 
2214
            pending = [(prefix, '', _directory, None, top_id, None)]
 
2215
        while pending:
 
2216
            dirblock = []
 
2217
            currentdir = pending.pop()
 
2218
            # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
 
2219
            top_id = currentdir[4]
 
2220
            if currentdir[0]:
 
2221
                relroot = currentdir[0] + '/'
 
2222
            else:
 
2223
                relroot = ""
 
2224
            # FIXME: stash the node in pending
 
2225
            entry = inv[top_id]
 
2226
            for name, child in entry.sorted_children():
 
2227
                dirblock.append((relroot + name, name, child.kind, None,
 
2228
                    child.file_id, child.kind
 
2229
                    ))
 
2230
            yield (currentdir[0], entry.file_id), dirblock
 
2231
            # push the user specified dirs from dirblock
 
2232
            for dir in reversed(dirblock):
 
2233
                if dir[2] == _directory:
 
2234
                    pending.append(dir)
1738
2235
 
1739
2236
    @needs_tree_write_lock
1740
2237
    def auto_resolve(self):
1744
2241
        are considered 'resolved', because bzr always puts conflict markers
1745
2242
        into files that have text conflicts.  The corresponding .THIS .BASE and
1746
2243
        .OTHER files are deleted, as per 'resolve'.
1747
 
 
1748
2244
        :return: a tuple of ConflictLists: (un_resolved, resolved).
1749
2245
        """
1750
2246
        un_resolved = _mod_conflicts.ConflictList()
1780
2276
        """
1781
2277
        return
1782
2278
 
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
 
 
1795
 
    def _get_rules_searcher(self, default_searcher):
1796
 
        """See Tree._get_rules_searcher."""
1797
 
        if self._rules_searcher is None:
1798
 
            self._rules_searcher = super(WorkingTree,
1799
 
                self)._get_rules_searcher(default_searcher)
1800
 
        return self._rules_searcher
1801
 
 
1802
 
    def get_shelf_manager(self):
1803
 
        """Return the ShelfManager for this WorkingTree."""
1804
 
        from bzrlib.shelf import ShelfManager
1805
 
        return ShelfManager(self, self._transport)
1806
 
 
1807
 
 
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.
 
2279
 
 
2280
class WorkingTree2(WorkingTree):
 
2281
    """This is the Format 2 working tree.
 
2282
 
 
2283
    This was the first weave based working tree. 
 
2284
     - uses os locks for locking.
 
2285
     - uses the branch last-revision.
1817
2286
    """
1818
2287
 
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)
 
2288
    def __init__(self, *args, **kwargs):
 
2289
        super(WorkingTree2, self).__init__(*args, **kwargs)
 
2290
        # WorkingTree2 has more of a constraint that self._inventory must
 
2291
        # exist. Because this is an older format, we don't mind the overhead
 
2292
        # caused by the extra computation here.
 
2293
 
 
2294
        # Newer WorkingTree's should only have self._inventory set when they
 
2295
        # have a read lock.
 
2296
        if self._inventory is None:
 
2297
            self.read_working_inventory()
 
2298
 
 
2299
    def lock_tree_write(self):
 
2300
        """See WorkingTree.lock_tree_write().
 
2301
 
 
2302
        In Format2 WorkingTrees we have a single lock for the branch and tree
 
2303
        so lock_tree_write() degrades to lock_write().
 
2304
        """
 
2305
        self.branch.lock_write()
 
2306
        try:
 
2307
            return self._control_files.lock_write()
 
2308
        except:
 
2309
            self.branch.unlock()
 
2310
            raise
 
2311
 
 
2312
    def unlock(self):
 
2313
        # we share control files:
 
2314
        if self._control_files._lock_count == 3:
 
2315
            # _inventory_is_modified is always False during a read lock.
 
2316
            if self._inventory_is_modified:
 
2317
                self.flush()
 
2318
            self._write_hashcache_if_dirty()
 
2319
                    
 
2320
        # reverse order of locking.
 
2321
        try:
 
2322
            return self._control_files.unlock()
1908
2323
        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
 
2324
            self.branch.unlock()
 
2325
 
 
2326
 
 
2327
class WorkingTree3(WorkingTree):
 
2328
    """This is the Format 3 working tree.
 
2329
 
 
2330
    This differs from the base WorkingTree by:
 
2331
     - having its own file lock
 
2332
     - having its own last-revision property.
 
2333
 
 
2334
    This is new in bzr 0.8
 
2335
    """
 
2336
 
 
2337
    @needs_read_lock
 
2338
    def _last_revision(self):
 
2339
        """See Mutable.last_revision."""
 
2340
        try:
 
2341
            return osutils.safe_revision_id(
 
2342
                        self._control_files.get('last-revision').read())
 
2343
        except errors.NoSuchFile:
 
2344
            return None
 
2345
 
 
2346
    def _change_last_revision(self, revision_id):
 
2347
        """See WorkingTree._change_last_revision."""
 
2348
        if revision_id is None or revision_id == NULL_REVISION:
 
2349
            try:
 
2350
                self._control_files._transport.delete('last-revision')
 
2351
            except errors.NoSuchFile:
 
2352
                pass
 
2353
            return False
1957
2354
        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)
 
2355
            self._control_files.put_bytes('last-revision', revision_id)
 
2356
            return True
2006
2357
 
2007
2358
    @needs_tree_write_lock
2008
2359
    def set_conflicts(self, conflicts):
2009
 
        self._put_rio('conflicts', conflicts.to_stanzas(),
 
2360
        self._put_rio('conflicts', conflicts.to_stanzas(), 
2010
2361
                      CONFLICT_HEADER_1)
2011
2362
 
2012
2363
    @needs_tree_write_lock
2019
2370
    @needs_read_lock
2020
2371
    def conflicts(self):
2021
2372
        try:
2022
 
            confile = self._transport.get('conflicts')
 
2373
            confile = self._control_files.get('conflicts')
2023
2374
        except errors.NoSuchFile:
2024
2375
            return _mod_conflicts.ConflictList()
2025
2376
        try:
2026
 
            try:
2027
 
                if confile.next() != CONFLICT_HEADER_1 + '\n':
2028
 
                    raise errors.ConflictFormatError()
2029
 
            except StopIteration:
 
2377
            if confile.next() != CONFLICT_HEADER_1 + '\n':
2030
2378
                raise errors.ConflictFormatError()
2031
 
            reader = _mod_rio.RioReader(confile)
2032
 
            return _mod_conflicts.ConflictList.from_stanzas(reader)
2033
 
        finally:
2034
 
            confile.close()
2035
 
 
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')
 
2379
        except StopIteration:
 
2380
            raise errors.ConflictFormatError()
 
2381
        return _mod_conflicts.ConflictList.from_stanzas(RioReader(confile))
 
2382
 
 
2383
    def unlock(self):
 
2384
        if self._control_files._lock_count == 1:
 
2385
            # _inventory_is_modified is always False during a read lock.
 
2386
            if self._inventory_is_modified:
 
2387
                self.flush()
 
2388
            self._write_hashcache_if_dirty()
 
2389
        # reverse order of locking.
2055
2390
        try:
2056
 
            result = self._deserialize(f)
 
2391
            return self._control_files.unlock()
2057
2392
        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:
 
2393
            self.branch.unlock()
 
2394
 
 
2395
 
 
2396
def get_conflicted_stem(path):
 
2397
    for suffix in _mod_conflicts.CONFLICT_SUFFIXES:
 
2398
        if path.endswith(suffix):
 
2399
            return path[:-len(suffix)]
 
2400
 
 
2401
 
 
2402
@deprecated_function(zero_eight)
 
2403
def is_control_file(filename):
 
2404
    """See WorkingTree.is_control_filename(filename)."""
 
2405
    ## FIXME: better check
 
2406
    filename = normpath(filename)
 
2407
    while filename != '':
 
2408
        head, tail = os.path.split(filename)
 
2409
        ## mutter('check %r for control file' % ((head, tail),))
 
2410
        if tail == '.bzr':
2077
2411
            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):
 
2412
        if filename == head:
 
2413
            break
 
2414
        filename = head
 
2415
    return False
 
2416
 
 
2417
 
 
2418
class WorkingTreeFormat(object):
2989
2419
    """An encapsulation of the initialization and open routines for a format.
2990
2420
 
2991
2421
    Formats provide three things:
2993
2423
     * a format string,
2994
2424
     * an open routine.
2995
2425
 
2996
 
    Formats are placed in an dict by their format string for reference
 
2426
    Formats are placed in an dict by their format string for reference 
2997
2427
    during workingtree opening. Its not required that these be instances, they
2998
 
    can be classes themselves with class methods - it simply depends on
 
2428
    can be classes themselves with class methods - it simply depends on 
2999
2429
    whether state is needed for a given format or not.
3000
2430
 
3001
2431
    Once a format is deprecated, just deprecate the initialize and open
3002
 
    methods on the format class. Do not deprecate the object, as the
 
2432
    methods on the format class. Do not deprecate the object, as the 
3003
2433
    object will be created every time regardless.
3004
2434
    """
3005
2435
 
 
2436
    _default_format = None
 
2437
    """The default format used for new trees."""
 
2438
 
 
2439
    _formats = {}
 
2440
    """The known formats."""
 
2441
 
3006
2442
    requires_rich_root = False
3007
2443
 
3008
2444
    upgrade_recommended = False
3009
2445
 
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
2446
    @classmethod
3020
 
    def find_format_string(klass, a_bzrdir):
3021
 
        """Return format name for the working tree object in a_bzrdir."""
 
2447
    def find_format(klass, a_bzrdir):
 
2448
        """Return the format for the working tree object in a_bzrdir."""
3022
2449
        try:
3023
2450
            transport = a_bzrdir.get_workingtree_transport(None)
3024
 
            return transport.get_bytes("format")
 
2451
            format_string = transport.get("format").read()
 
2452
            return klass._formats[format_string]
3025
2453
        except errors.NoSuchFile:
3026
2454
            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
2455
        except KeyError:
3035
 
            raise errors.UnknownFormatError(format=format_string,
3036
 
                                            kind="working tree")
3037
 
 
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)
 
2456
            raise errors.UnknownFormatError(format=format_string)
3054
2457
 
3055
2458
    def __eq__(self, other):
3056
2459
        return self.__class__ is other.__class__
3059
2462
        return not (self == other)
3060
2463
 
3061
2464
    @classmethod
3062
 
    @symbol_versioning.deprecated_method(
3063
 
        symbol_versioning.deprecated_in((2, 4, 0)))
3064
2465
    def get_default_format(klass):
3065
2466
        """Return the current default format."""
3066
 
        return format_registry.get_default()
 
2467
        return klass._default_format
3067
2468
 
3068
2469
    def get_format_string(self):
3069
2470
        """Return the ASCII format string that identifies this format."""
3077
2478
        """Is this format supported?
3078
2479
 
3079
2480
        Supported formats can be initialized and opened.
3080
 
        Unsupported formats may not support initialization or committing or
 
2481
        Unsupported formats may not support initialization or committing or 
3081
2482
        some other features depending on the reason for not being supported.
3082
2483
        """
3083
2484
        return True
3084
2485
 
3085
 
    def supports_content_filtering(self):
3086
 
        """True if this format supports content filtering."""
3087
 
        return False
3088
 
 
3089
 
    def supports_views(self):
3090
 
        """True if this format supports stored views."""
3091
 
        return False
3092
 
 
3093
2486
    @classmethod
3094
 
    @symbol_versioning.deprecated_method(
3095
 
        symbol_versioning.deprecated_in((2, 4, 0)))
3096
2487
    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)))
 
2488
        klass._formats[format.get_format_string()] = format
 
2489
 
 
2490
    @classmethod
3120
2491
    def set_default_format(klass, format):
3121
 
        format_registry.set_default(format)
 
2492
        klass._default_format = format
3122
2493
 
3123
2494
    @classmethod
3124
 
    @symbol_versioning.deprecated_method(
3125
 
        symbol_versioning.deprecated_in((2, 4, 0)))
3126
2495
    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")
 
2496
        assert klass._formats[format.get_format_string()] is format
 
2497
        del klass._formats[format.get_format_string()]
 
2498
 
 
2499
 
 
2500
class WorkingTreeFormat2(WorkingTreeFormat):
 
2501
    """The second working tree format. 
 
2502
 
 
2503
    This format modified the hash cache from the format 1 hash cache.
 
2504
    """
 
2505
 
 
2506
    upgrade_recommended = True
 
2507
 
 
2508
    def get_format_description(self):
 
2509
        """See WorkingTreeFormat.get_format_description()."""
 
2510
        return "Working tree format 2"
 
2511
 
 
2512
    def stub_initialize_remote(self, control_files):
 
2513
        """As a special workaround create critical control files for a remote working tree
 
2514
        
 
2515
        This ensures that it can later be updated and dealt with locally,
 
2516
        since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with 
 
2517
        no working tree.  (See bug #43064).
 
2518
        """
 
2519
        sio = StringIO()
 
2520
        inv = Inventory()
 
2521
        xml5.serializer_v5.write_inventory(inv, sio)
 
2522
        sio.seek(0)
 
2523
        control_files.put('inventory', sio)
 
2524
 
 
2525
        control_files.put_bytes('pending-merges', '')
 
2526
        
 
2527
 
 
2528
    def initialize(self, a_bzrdir, revision_id=None):
 
2529
        """See WorkingTreeFormat.initialize()."""
 
2530
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
2531
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
2532
        branch = a_bzrdir.open_branch()
 
2533
        if revision_id is not None:
 
2534
            revision_id = osutils.safe_revision_id(revision_id)
 
2535
            branch.lock_write()
 
2536
            try:
 
2537
                revision_history = branch.revision_history()
 
2538
                try:
 
2539
                    position = revision_history.index(revision_id)
 
2540
                except ValueError:
 
2541
                    raise errors.NoSuchRevision(branch, revision_id)
 
2542
                branch.set_revision_history(revision_history[:position + 1])
 
2543
            finally:
 
2544
                branch.unlock()
 
2545
        revision = branch.last_revision()
 
2546
        inv = Inventory()
 
2547
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
 
2548
                         branch,
 
2549
                         inv,
 
2550
                         _internal=True,
 
2551
                         _format=self,
 
2552
                         _bzrdir=a_bzrdir)
 
2553
        basis_tree = branch.repository.revision_tree(revision)
 
2554
        if basis_tree.inventory.root is not None:
 
2555
            wt.set_root_id(basis_tree.inventory.root.file_id)
 
2556
        # set the parent list and cache the basis tree.
 
2557
        wt.set_parent_trees([(revision, basis_tree)])
 
2558
        transform.build_tree(basis_tree, wt)
 
2559
        return wt
 
2560
 
 
2561
    def __init__(self):
 
2562
        super(WorkingTreeFormat2, self).__init__()
 
2563
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
 
2564
 
 
2565
    def open(self, a_bzrdir, _found=False):
 
2566
        """Return the WorkingTree object for a_bzrdir
 
2567
 
 
2568
        _found is a private parameter, do not use it. It is used to indicate
 
2569
               if format probing has already been done.
 
2570
        """
 
2571
        if not _found:
 
2572
            # we are being called directly and must probe.
 
2573
            raise NotImplementedError
 
2574
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
2575
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
2576
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
 
2577
                           _internal=True,
 
2578
                           _format=self,
 
2579
                           _bzrdir=a_bzrdir)
 
2580
        return wt
 
2581
 
 
2582
class WorkingTreeFormat3(WorkingTreeFormat):
 
2583
    """The second working tree format updated to record a format marker.
 
2584
 
 
2585
    This format:
 
2586
        - exists within a metadir controlling .bzr
 
2587
        - includes an explicit version marker for the workingtree control
 
2588
          files, separate from the BzrDir format
 
2589
        - modifies the hash cache format
 
2590
        - is new in bzr 0.8
 
2591
        - uses a LockDir to guard access for writes.
 
2592
    """
 
2593
    
 
2594
    upgrade_recommended = True
 
2595
 
 
2596
    def get_format_string(self):
 
2597
        """See WorkingTreeFormat.get_format_string()."""
 
2598
        return "Bazaar-NG Working Tree format 3"
 
2599
 
 
2600
    def get_format_description(self):
 
2601
        """See WorkingTreeFormat.get_format_description()."""
 
2602
        return "Working tree format 3"
 
2603
 
 
2604
    _lock_file_name = 'lock'
 
2605
    _lock_class = LockDir
 
2606
 
 
2607
    _tree_class = WorkingTree3
 
2608
 
 
2609
    def __get_matchingbzrdir(self):
 
2610
        return bzrdir.BzrDirMetaFormat1()
 
2611
 
 
2612
    _matchingbzrdir = property(__get_matchingbzrdir)
 
2613
 
 
2614
    def _open_control_files(self, a_bzrdir):
 
2615
        transport = a_bzrdir.get_workingtree_transport(None)
 
2616
        return LockableFiles(transport, self._lock_file_name, 
 
2617
                             self._lock_class)
 
2618
 
 
2619
    def initialize(self, a_bzrdir, revision_id=None):
 
2620
        """See WorkingTreeFormat.initialize().
 
2621
        
 
2622
        revision_id allows creating a working tree at a different
 
2623
        revision than the branch is at.
 
2624
        """
 
2625
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
2626
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
2627
        transport = a_bzrdir.get_workingtree_transport(self)
 
2628
        control_files = self._open_control_files(a_bzrdir)
 
2629
        control_files.create_lock()
 
2630
        control_files.lock_write()
 
2631
        control_files.put_utf8('format', self.get_format_string())
 
2632
        branch = a_bzrdir.open_branch()
 
2633
        if revision_id is None:
 
2634
            revision_id = branch.last_revision()
 
2635
        else:
 
2636
            revision_id = osutils.safe_revision_id(revision_id)
 
2637
        # WorkingTree3 can handle an inventory which has a unique root id.
 
2638
        # as of bzr 0.12. However, bzr 0.11 and earlier fail to handle
 
2639
        # those trees. And because there isn't a format bump inbetween, we
 
2640
        # are maintaining compatibility with older clients.
 
2641
        # inv = Inventory(root_id=gen_root_id())
 
2642
        inv = self._initial_inventory()
 
2643
        wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
2644
                         branch,
 
2645
                         inv,
 
2646
                         _internal=True,
 
2647
                         _format=self,
 
2648
                         _bzrdir=a_bzrdir,
 
2649
                         _control_files=control_files)
 
2650
        wt.lock_tree_write()
 
2651
        try:
 
2652
            basis_tree = branch.repository.revision_tree(revision_id)
 
2653
            # only set an explicit root id if there is one to set.
 
2654
            if basis_tree.inventory.root is not None:
 
2655
                wt.set_root_id(basis_tree.inventory.root.file_id)
 
2656
            if revision_id == NULL_REVISION:
 
2657
                wt.set_parent_trees([])
 
2658
            else:
 
2659
                wt.set_parent_trees([(revision_id, basis_tree)])
 
2660
            transform.build_tree(basis_tree, wt)
 
2661
        finally:
 
2662
            # Unlock in this order so that the unlock-triggers-flush in
 
2663
            # WorkingTree is given a chance to fire.
 
2664
            control_files.unlock()
 
2665
            wt.unlock()
 
2666
        return wt
 
2667
 
 
2668
    def _initial_inventory(self):
 
2669
        return Inventory()
 
2670
 
 
2671
    def __init__(self):
 
2672
        super(WorkingTreeFormat3, self).__init__()
 
2673
 
 
2674
    def open(self, a_bzrdir, _found=False):
 
2675
        """Return the WorkingTree object for a_bzrdir
 
2676
 
 
2677
        _found is a private parameter, do not use it. It is used to indicate
 
2678
               if format probing has already been done.
 
2679
        """
 
2680
        if not _found:
 
2681
            # we are being called directly and must probe.
 
2682
            raise NotImplementedError
 
2683
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
2684
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
2685
        wt = self._open(a_bzrdir, self._open_control_files(a_bzrdir))
 
2686
        return wt
 
2687
 
 
2688
    def _open(self, a_bzrdir, control_files):
 
2689
        """Open the tree itself.
 
2690
        
 
2691
        :param a_bzrdir: the dir for the tree.
 
2692
        :param control_files: the control files for the tree.
 
2693
        """
 
2694
        return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
2695
                                _internal=True,
 
2696
                                _format=self,
 
2697
                                _bzrdir=a_bzrdir,
 
2698
                                _control_files=control_files)
 
2699
 
 
2700
    def __str__(self):
 
2701
        return self.get_format_string()
 
2702
 
 
2703
 
 
2704
__default_format = WorkingTreeFormat4()
 
2705
WorkingTreeFormat.register_format(__default_format)
 
2706
WorkingTreeFormat.register_format(WorkingTreeFormat3())
 
2707
WorkingTreeFormat.set_default_format(__default_format)
 
2708
# formats which have no format string are not discoverable
 
2709
# and not independently creatable, so are not registered.
 
2710
_legacy_formats = [WorkingTreeFormat2(),
 
2711
                   ]
 
2712
 
 
2713
 
 
2714
class WorkingTreeTestProviderAdapter(object):
 
2715
    """A tool to generate a suite testing multiple workingtree formats at once.
 
2716
 
 
2717
    This is done by copying the test once for each transport and injecting
 
2718
    the transport_server, transport_readonly_server, and workingtree_format
 
2719
    classes into each copy. Each copy is also given a new id() to make it
 
2720
    easy to identify.
 
2721
    """
 
2722
 
 
2723
    def __init__(self, transport_server, transport_readonly_server, formats):
 
2724
        self._transport_server = transport_server
 
2725
        self._transport_readonly_server = transport_readonly_server
 
2726
        self._formats = formats
 
2727
    
 
2728
    def _clone_test(self, test, bzrdir_format, workingtree_format, variation):
 
2729
        """Clone test for adaption."""
 
2730
        new_test = deepcopy(test)
 
2731
        new_test.transport_server = self._transport_server
 
2732
        new_test.transport_readonly_server = self._transport_readonly_server
 
2733
        new_test.bzrdir_format = bzrdir_format
 
2734
        new_test.workingtree_format = workingtree_format
 
2735
        def make_new_test_id():
 
2736
            new_id = "%s(%s)" % (test.id(), variation)
 
2737
            return lambda: new_id
 
2738
        new_test.id = make_new_test_id()
 
2739
        return new_test
 
2740
    
 
2741
    def adapt(self, test):
 
2742
        from bzrlib.tests import TestSuite
 
2743
        result = TestSuite()
 
2744
        for workingtree_format, bzrdir_format in self._formats:
 
2745
            new_test = self._clone_test(
 
2746
                test,
 
2747
                bzrdir_format,
 
2748
                workingtree_format, workingtree_format.__class__.__name__)
 
2749
            result.addTest(new_test)
 
2750
        return result