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