/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

Combine the ignore rules into a single regex rather than looping over them
to reduce the threshold where  N^2 behaviour occurs in operations like
status. (Jan Hudec, Robert Collins).

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""WorkingTree object and friends.
 
18
 
 
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 
 
23
new revision based on the workingtree and its inventory.
 
24
 
 
25
At the moment every WorkingTree has its own branch.  Remote
 
26
WorkingTrees aren't supported.
 
27
 
 
28
To get a WorkingTree, call bzrdir.open_workingtree() or
 
29
WorkingTree.open(dir).
 
30
"""
 
31
 
 
32
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
 
33
CONFLICT_HEADER_1 = "BZR conflict list format 1"
 
34
 
 
35
# TODO: Give the workingtree sole responsibility for the working inventory;
 
36
# remove the variable and references to it from the branch.  This may require
 
37
# updating the commit code so as to update the inventory within the working
 
38
# copy, and making sure there's only one WorkingTree for any directory on disk.
 
39
# At the moment they may alias the inventory and have old copies of it in
 
40
# memory.  (Now done? -- mbp 20060309)
 
41
 
 
42
from binascii import hexlify
 
43
from copy import deepcopy
 
44
from cStringIO import StringIO
 
45
import errno
 
46
import fnmatch
 
47
import os
 
48
import re
 
49
import stat
 
50
from time import time
 
51
 
 
52
from bzrlib.atomicfile import AtomicFile
 
53
from bzrlib.branch import (Branch,
 
54
                           quotefn)
 
55
from bzrlib.conflicts import Conflict, ConflictList, CONFLICT_SUFFIXES
 
56
import bzrlib.bzrdir as bzrdir
 
57
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
58
import bzrlib.errors as errors
 
59
from bzrlib.errors import (BzrCheckError,
 
60
                           BzrError,
 
61
                           ConflictFormatError,
 
62
                           DivergedBranches,
 
63
                           WeaveRevisionNotPresent,
 
64
                           NotBranchError,
 
65
                           NoSuchFile,
 
66
                           NotVersionedError,
 
67
                           MergeModifiedFormatError,
 
68
                           UnsupportedOperation,
 
69
                           )
 
70
from bzrlib.inventory import InventoryEntry, Inventory
 
71
from bzrlib.lockable_files import LockableFiles, TransportLock
 
72
from bzrlib.lockdir import LockDir
 
73
from bzrlib.merge import merge_inner, transform_tree
 
74
from bzrlib.osutils import (
 
75
                            abspath,
 
76
                            appendpath,
 
77
                            compact_date,
 
78
                            file_kind,
 
79
                            isdir,
 
80
                            getcwd,
 
81
                            pathjoin,
 
82
                            pumpfile,
 
83
                            safe_unicode,
 
84
                            splitpath,
 
85
                            rand_chars,
 
86
                            normpath,
 
87
                            realpath,
 
88
                            relpath,
 
89
                            rename,
 
90
                            supports_executable,
 
91
                            )
 
92
from bzrlib.progress import DummyProgress, ProgressPhase
 
93
from bzrlib.revision import NULL_REVISION
 
94
from bzrlib.rio import RioReader, rio_file, Stanza
 
95
from bzrlib.symbol_versioning import *
 
96
from bzrlib.textui import show_status
 
97
import bzrlib.tree
 
98
from bzrlib.transform import build_tree
 
99
from bzrlib.trace import mutter, note
 
100
from bzrlib.transport import get_transport
 
101
from bzrlib.transport.local import LocalTransport
 
102
import bzrlib.ui
 
103
import bzrlib.xml5
 
104
 
 
105
 
 
106
# the regex here does the following:
 
107
# 1) remove any weird characters; we don't escape them but rather
 
108
# just pull them out
 
109
 # 2) match leading '.'s to make it not hidden
 
110
_gen_file_id_re = re.compile(r'[^\w.]|(^\.*)')
 
111
_gen_id_suffix = None
 
112
_gen_id_serial = 0
 
113
 
 
114
 
 
115
def _next_id_suffix():
 
116
    """Create a new file id suffix that is reasonably unique.
 
117
    
 
118
    On the first call we combine the current time with 64 bits of randomness
 
119
    to give a highly probably globally unique number. Then each call in the same
 
120
    process adds 1 to a serial number we append to that unique value.
 
121
    """
 
122
    # XXX TODO: change bzrlib.add.smart_add to call workingtree.add() rather 
 
123
    # than having to move the id randomness out of the inner loop like this.
 
124
    # XXX TODO: for the global randomness this uses we should add the thread-id
 
125
    # before the serial #.
 
126
    global _gen_id_suffix, _gen_id_serial
 
127
    if _gen_id_suffix is None:
 
128
        _gen_id_suffix = "-%s-%s-" % (compact_date(time()), rand_chars(16))
 
129
    _gen_id_serial += 1
 
130
    return _gen_id_suffix + str(_gen_id_serial)
 
131
 
 
132
 
 
133
def gen_file_id(name):
 
134
    """Return new file id for the basename 'name'.
 
135
 
 
136
    The uniqueness is supplied from _next_id_suffix.
 
137
    """
 
138
    # XXX TODO: squash the filename to lowercase.
 
139
    # XXX TODO: truncate the filename to something like 20 or 30 chars.
 
140
    # XXX TODO: consider what to do with ids that look like illegal filepaths
 
141
    # on platforms we support.
 
142
    return _gen_file_id_re.sub('', name) + _next_id_suffix()
 
143
 
 
144
 
 
145
def gen_root_id():
 
146
    """Return a new tree-root file id."""
 
147
    return gen_file_id('TREE_ROOT')
 
148
 
 
149
 
 
150
class TreeEntry(object):
 
151
    """An entry that implements the minium interface used by commands.
 
152
 
 
153
    This needs further inspection, it may be better to have 
 
154
    InventoryEntries without ids - though that seems wrong. For now,
 
155
    this is a parallel hierarchy to InventoryEntry, and needs to become
 
156
    one of several things: decorates to that hierarchy, children of, or
 
157
    parents of it.
 
158
    Another note is that these objects are currently only used when there is
 
159
    no InventoryEntry available - i.e. for unversioned objects.
 
160
    Perhaps they should be UnversionedEntry et al. ? - RBC 20051003
 
161
    """
 
162
 
 
163
    def __eq__(self, other):
 
164
        # yes, this us ugly, TODO: best practice __eq__ style.
 
165
        return (isinstance(other, TreeEntry)
 
166
                and other.__class__ == self.__class__)
 
167
 
 
168
    def kind_character(self):
 
169
        return "???"
 
170
 
 
171
 
 
172
class TreeDirectory(TreeEntry):
 
173
    """See TreeEntry. This is a directory in a working tree."""
 
174
 
 
175
    def __eq__(self, other):
 
176
        return (isinstance(other, TreeDirectory)
 
177
                and other.__class__ == self.__class__)
 
178
 
 
179
    def kind_character(self):
 
180
        return "/"
 
181
 
 
182
 
 
183
class TreeFile(TreeEntry):
 
184
    """See TreeEntry. This is a regular file in a working tree."""
 
185
 
 
186
    def __eq__(self, other):
 
187
        return (isinstance(other, TreeFile)
 
188
                and other.__class__ == self.__class__)
 
189
 
 
190
    def kind_character(self):
 
191
        return ''
 
192
 
 
193
 
 
194
class TreeLink(TreeEntry):
 
195
    """See TreeEntry. This is a symlink in a working tree."""
 
196
 
 
197
    def __eq__(self, other):
 
198
        return (isinstance(other, TreeLink)
 
199
                and other.__class__ == self.__class__)
 
200
 
 
201
    def kind_character(self):
 
202
        return ''
 
203
 
 
204
 
 
205
class WorkingTree(bzrlib.tree.Tree):
 
206
    """Working copy tree.
 
207
 
 
208
    The inventory is held in the `Branch` working-inventory, and the
 
209
    files are in a directory on disk.
 
210
 
 
211
    It is possible for a `WorkingTree` to have a filename which is
 
212
    not listed in the Inventory and vice versa.
 
213
    """
 
214
 
 
215
    def __init__(self, basedir='.',
 
216
                 branch=DEPRECATED_PARAMETER,
 
217
                 _inventory=None,
 
218
                 _control_files=None,
 
219
                 _internal=False,
 
220
                 _format=None,
 
221
                 _bzrdir=None):
 
222
        """Construct a WorkingTree for basedir.
 
223
 
 
224
        If the branch is not supplied, it is opened automatically.
 
225
        If the branch is supplied, it must be the branch for this basedir.
 
226
        (branch.base is not cross checked, because for remote branches that
 
227
        would be meaningless).
 
228
        """
 
229
        self._format = _format
 
230
        self.bzrdir = _bzrdir
 
231
        if not _internal:
 
232
            # not created via open etc.
 
233
            warn("WorkingTree() is deprecated as of bzr version 0.8. "
 
234
                 "Please use bzrdir.open_workingtree or WorkingTree.open().",
 
235
                 DeprecationWarning,
 
236
                 stacklevel=2)
 
237
            wt = WorkingTree.open(basedir)
 
238
            self._branch = wt.branch
 
239
            self.basedir = wt.basedir
 
240
            self._control_files = wt._control_files
 
241
            self._hashcache = wt._hashcache
 
242
            self._set_inventory(wt._inventory)
 
243
            self._format = wt._format
 
244
            self.bzrdir = wt.bzrdir
 
245
        from bzrlib.hashcache import HashCache
 
246
        from bzrlib.trace import note, mutter
 
247
        assert isinstance(basedir, basestring), \
 
248
            "base directory %r is not a string" % basedir
 
249
        basedir = safe_unicode(basedir)
 
250
        mutter("opening working tree %r", basedir)
 
251
        if deprecated_passed(branch):
 
252
            if not _internal:
 
253
                warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
 
254
                     " Please use bzrdir.open_workingtree() or"
 
255
                     " WorkingTree.open().",
 
256
                     DeprecationWarning,
 
257
                     stacklevel=2
 
258
                     )
 
259
            self._branch = branch
 
260
        else:
 
261
            self._branch = self.bzrdir.open_branch()
 
262
        assert isinstance(self.branch, Branch), \
 
263
            "branch %r is not a Branch" % self.branch
 
264
        self.basedir = realpath(basedir)
 
265
        # if branch is at our basedir and is a format 6 or less
 
266
        if isinstance(self._format, WorkingTreeFormat2):
 
267
            # share control object
 
268
            self._control_files = self.branch.control_files
 
269
        else:
 
270
            # only ready for format 3
 
271
            assert isinstance(self._format, WorkingTreeFormat3)
 
272
            assert isinstance(_control_files, LockableFiles), \
 
273
                    "_control_files must be a LockableFiles, not %r" \
 
274
                    % _control_files
 
275
            self._control_files = _control_files
 
276
        # update the whole cache up front and write to disk if anything changed;
 
277
        # in the future we might want to do this more selectively
 
278
        # two possible ways offer themselves : in self._unlock, write the cache
 
279
        # if needed, or, when the cache sees a change, append it to the hash
 
280
        # cache file, and have the parser take the most recent entry for a
 
281
        # given path only.
 
282
        cache_filename = self.bzrdir.get_workingtree_transport(None).abspath('stat-cache')
 
283
        hc = self._hashcache = HashCache(basedir, cache_filename, self._control_files._file_mode)
 
284
        hc.read()
 
285
        # is this scan needed ? it makes things kinda slow.
 
286
        hc.scan()
 
287
 
 
288
        if hc.needs_write:
 
289
            mutter("write hc")
 
290
            hc.write()
 
291
 
 
292
        if _inventory is None:
 
293
            self._set_inventory(self.read_working_inventory())
 
294
        else:
 
295
            self._set_inventory(_inventory)
 
296
 
 
297
    branch = property(
 
298
        fget=lambda self: self._branch,
 
299
        doc="""The branch this WorkingTree is connected to.
 
300
 
 
301
            This cannot be set - it is reflective of the actual disk structure
 
302
            the working tree has been constructed from.
 
303
            """)
 
304
 
 
305
    def break_lock(self):
 
306
        """Break a lock if one is present from another instance.
 
307
 
 
308
        Uses the ui factory to ask for confirmation if the lock may be from
 
309
        an active process.
 
310
 
 
311
        This will probe the repository for its lock as well.
 
312
        """
 
313
        self._control_files.break_lock()
 
314
        self.branch.break_lock()
 
315
 
 
316
    def _set_inventory(self, inv):
 
317
        self._inventory = inv
 
318
        self.path2id = self._inventory.path2id
 
319
 
 
320
    def is_control_filename(self, filename):
 
321
        """True if filename is the name of a control file in this tree.
 
322
        
 
323
        This is true IF and ONLY IF the filename is part of the meta data
 
324
        that bzr controls in this tree. I.E. a random .bzr directory placed
 
325
        on disk will not be a control file for this tree.
 
326
        """
 
327
        try:
 
328
            self.bzrdir.transport.relpath(self.abspath(filename))
 
329
            return True
 
330
        except errors.PathNotChild:
 
331
            return False
 
332
 
 
333
    @staticmethod
 
334
    def open(path=None, _unsupported=False):
 
335
        """Open an existing working tree at path.
 
336
 
 
337
        """
 
338
        if path is None:
 
339
            path = os.path.getcwdu()
 
340
        control = bzrdir.BzrDir.open(path, _unsupported)
 
341
        return control.open_workingtree(_unsupported)
 
342
        
 
343
    @staticmethod
 
344
    def open_containing(path=None):
 
345
        """Open an existing working tree which has its root about path.
 
346
        
 
347
        This probes for a working tree at path and searches upwards from there.
 
348
 
 
349
        Basically we keep looking up until we find the control directory or
 
350
        run into /.  If there isn't one, raises NotBranchError.
 
351
        TODO: give this a new exception.
 
352
        If there is one, it is returned, along with the unused portion of path.
 
353
        """
 
354
        if path is None:
 
355
            path = os.getcwdu()
 
356
        control, relpath = bzrdir.BzrDir.open_containing(path)
 
357
        return control.open_workingtree(), relpath
 
358
 
 
359
    @staticmethod
 
360
    def open_downlevel(path=None):
 
361
        """Open an unsupported working tree.
 
362
 
 
363
        Only intended for advanced situations like upgrading part of a bzrdir.
 
364
        """
 
365
        return WorkingTree.open(path, _unsupported=True)
 
366
 
 
367
    def __iter__(self):
 
368
        """Iterate through file_ids for this tree.
 
369
 
 
370
        file_ids are in a WorkingTree if they are in the working inventory
 
371
        and the working file exists.
 
372
        """
 
373
        inv = self._inventory
 
374
        for path, ie in inv.iter_entries():
 
375
            if bzrlib.osutils.lexists(self.abspath(path)):
 
376
                yield ie.file_id
 
377
 
 
378
    def __repr__(self):
 
379
        return "<%s of %s>" % (self.__class__.__name__,
 
380
                               getattr(self, 'basedir', None))
 
381
 
 
382
    def abspath(self, filename):
 
383
        return pathjoin(self.basedir, filename)
 
384
    
 
385
    def basis_tree(self):
 
386
        """Return RevisionTree for the current last revision."""
 
387
        revision_id = self.last_revision()
 
388
        if revision_id is not None:
 
389
            try:
 
390
                xml = self.read_basis_inventory()
 
391
                inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
392
            except NoSuchFile:
 
393
                inv = None
 
394
            if inv is not None and inv.revision_id == revision_id:
 
395
                return bzrlib.tree.RevisionTree(self.branch.repository, inv,
 
396
                                                revision_id)
 
397
        # FIXME? RBC 20060403 should we cache the inventory here ?
 
398
        return self.branch.repository.revision_tree(revision_id)
 
399
 
 
400
    @staticmethod
 
401
    @deprecated_method(zero_eight)
 
402
    def create(branch, directory):
 
403
        """Create a workingtree for branch at directory.
 
404
 
 
405
        If existing_directory already exists it must have a .bzr directory.
 
406
        If it does not exist, it will be created.
 
407
 
 
408
        This returns a new WorkingTree object for the new checkout.
 
409
 
 
410
        TODO FIXME RBC 20060124 when we have checkout formats in place this
 
411
        should accept an optional revisionid to checkout [and reject this if
 
412
        checking out into the same dir as a pre-checkout-aware branch format.]
 
413
 
 
414
        XXX: When BzrDir is present, these should be created through that 
 
415
        interface instead.
 
416
        """
 
417
        warn('delete WorkingTree.create', stacklevel=3)
 
418
        transport = get_transport(directory)
 
419
        if branch.bzrdir.root_transport.base == transport.base:
 
420
            # same dir 
 
421
            return branch.bzrdir.create_workingtree()
 
422
        # different directory, 
 
423
        # create a branch reference
 
424
        # and now a working tree.
 
425
        raise NotImplementedError
 
426
 
 
427
    @staticmethod
 
428
    @deprecated_method(zero_eight)
 
429
    def create_standalone(directory):
 
430
        """Create a checkout and a branch and a repo at directory.
 
431
 
 
432
        Directory must exist and be empty.
 
433
 
 
434
        please use BzrDir.create_standalone_workingtree
 
435
        """
 
436
        return bzrdir.BzrDir.create_standalone_workingtree(directory)
 
437
 
 
438
    def relpath(self, abs):
 
439
        """Return the local path portion from a given absolute path."""
 
440
        return relpath(self.basedir, abs)
 
441
 
 
442
    def has_filename(self, filename):
 
443
        return bzrlib.osutils.lexists(self.abspath(filename))
 
444
 
 
445
    def get_file(self, file_id):
 
446
        return self.get_file_byname(self.id2path(file_id))
 
447
 
 
448
    def get_file_byname(self, filename):
 
449
        return file(self.abspath(filename), 'rb')
 
450
 
 
451
    def get_root_id(self):
 
452
        """Return the id of this trees root"""
 
453
        inv = self.read_working_inventory()
 
454
        return inv.root.file_id
 
455
        
 
456
    def _get_store_filename(self, file_id):
 
457
        ## XXX: badly named; this is not in the store at all
 
458
        return self.abspath(self.id2path(file_id))
 
459
 
 
460
    @needs_read_lock
 
461
    def clone(self, to_bzrdir, revision_id=None, basis=None):
 
462
        """Duplicate this working tree into to_bzr, including all state.
 
463
        
 
464
        Specifically modified files are kept as modified, but
 
465
        ignored and unknown files are discarded.
 
466
 
 
467
        If you want to make a new line of development, see bzrdir.sprout()
 
468
 
 
469
        revision
 
470
            If not None, the cloned tree will have its last revision set to 
 
471
            revision, and and difference between the source trees last revision
 
472
            and this one merged in.
 
473
 
 
474
        basis
 
475
            If not None, a closer copy of a tree which may have some files in
 
476
            common, and which file content should be preferentially copied from.
 
477
        """
 
478
        # assumes the target bzr dir format is compatible.
 
479
        result = self._format.initialize(to_bzrdir)
 
480
        self.copy_content_into(result, revision_id)
 
481
        return result
 
482
 
 
483
    @needs_read_lock
 
484
    def copy_content_into(self, tree, revision_id=None):
 
485
        """Copy the current content and user files of this tree into tree."""
 
486
        if revision_id is None:
 
487
            transform_tree(tree, self)
 
488
        else:
 
489
            # TODO now merge from tree.last_revision to revision
 
490
            transform_tree(tree, self)
 
491
            tree.set_last_revision(revision_id)
 
492
 
 
493
    @needs_write_lock
 
494
    def commit(self, message=None, revprops=None, *args, **kwargs):
 
495
        # avoid circular imports
 
496
        from bzrlib.commit import Commit
 
497
        if revprops is None:
 
498
            revprops = {}
 
499
        if not 'branch-nick' in revprops:
 
500
            revprops['branch-nick'] = self.branch.nick
 
501
        # args for wt.commit start at message from the Commit.commit method,
 
502
        # but with branch a kwarg now, passing in args as is results in the
 
503
        #message being used for the branch
 
504
        args = (DEPRECATED_PARAMETER, message, ) + args
 
505
        Commit().commit(working_tree=self, revprops=revprops, *args, **kwargs)
 
506
        self._set_inventory(self.read_working_inventory())
 
507
 
 
508
    def id2abspath(self, file_id):
 
509
        return self.abspath(self.id2path(file_id))
 
510
 
 
511
    def has_id(self, file_id):
 
512
        # files that have been deleted are excluded
 
513
        inv = self._inventory
 
514
        if not inv.has_id(file_id):
 
515
            return False
 
516
        path = inv.id2path(file_id)
 
517
        return bzrlib.osutils.lexists(self.abspath(path))
 
518
 
 
519
    def has_or_had_id(self, file_id):
 
520
        if file_id == self.inventory.root.file_id:
 
521
            return True
 
522
        return self.inventory.has_id(file_id)
 
523
 
 
524
    __contains__ = has_id
 
525
 
 
526
    def get_file_size(self, file_id):
 
527
        return os.path.getsize(self.id2abspath(file_id))
 
528
 
 
529
    @needs_read_lock
 
530
    def get_file_sha1(self, file_id):
 
531
        path = self._inventory.id2path(file_id)
 
532
        return self._hashcache.get_sha1(path)
 
533
 
 
534
    def is_executable(self, file_id):
 
535
        if not supports_executable():
 
536
            return self._inventory[file_id].executable
 
537
        else:
 
538
            path = self._inventory.id2path(file_id)
 
539
            mode = os.lstat(self.abspath(path)).st_mode
 
540
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC&mode)
 
541
 
 
542
    @needs_write_lock
 
543
    def add(self, files, ids=None):
 
544
        """Make files versioned.
 
545
 
 
546
        Note that the command line normally calls smart_add instead,
 
547
        which can automatically recurse.
 
548
 
 
549
        This adds the files to the inventory, so that they will be
 
550
        recorded by the next commit.
 
551
 
 
552
        files
 
553
            List of paths to add, relative to the base of the tree.
 
554
 
 
555
        ids
 
556
            If set, use these instead of automatically generated ids.
 
557
            Must be the same length as the list of files, but may
 
558
            contain None for ids that are to be autogenerated.
 
559
 
 
560
        TODO: Perhaps have an option to add the ids even if the files do
 
561
              not (yet) exist.
 
562
 
 
563
        TODO: Perhaps callback with the ids and paths as they're added.
 
564
        """
 
565
        # TODO: Re-adding a file that is removed in the working copy
 
566
        # should probably put it back with the previous ID.
 
567
        if isinstance(files, basestring):
 
568
            assert(ids is None or isinstance(ids, basestring))
 
569
            files = [files]
 
570
            if ids is not None:
 
571
                ids = [ids]
 
572
 
 
573
        if ids is None:
 
574
            ids = [None] * len(files)
 
575
        else:
 
576
            assert(len(ids) == len(files))
 
577
 
 
578
        inv = self.read_working_inventory()
 
579
        for f,file_id in zip(files, ids):
 
580
            if self.is_control_filename(f):
 
581
                raise BzrError("cannot add control file %s" % quotefn(f))
 
582
 
 
583
            fp = splitpath(f)
 
584
 
 
585
            if len(fp) == 0:
 
586
                raise BzrError("cannot add top-level %r" % f)
 
587
 
 
588
            fullpath = normpath(self.abspath(f))
 
589
 
 
590
            try:
 
591
                kind = file_kind(fullpath)
 
592
            except OSError, e:
 
593
                if e.errno == errno.ENOENT:
 
594
                    raise NoSuchFile(fullpath)
 
595
                # maybe something better?
 
596
                raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
 
597
 
 
598
            if not InventoryEntry.versionable_kind(kind):
 
599
                raise BzrError('cannot add: not a versionable file ('
 
600
                               'i.e. regular file, symlink or directory): %s' % quotefn(f))
 
601
 
 
602
            if file_id is None:
 
603
                inv.add_path(f, kind=kind)
 
604
            else:
 
605
                inv.add_path(f, kind=kind, file_id=file_id)
 
606
 
 
607
        self._write_inventory(inv)
 
608
 
 
609
    @needs_write_lock
 
610
    def add_pending_merge(self, *revision_ids):
 
611
        # TODO: Perhaps should check at this point that the
 
612
        # history of the revision is actually present?
 
613
        p = self.pending_merges()
 
614
        updated = False
 
615
        for rev_id in revision_ids:
 
616
            if rev_id in p:
 
617
                continue
 
618
            p.append(rev_id)
 
619
            updated = True
 
620
        if updated:
 
621
            self.set_pending_merges(p)
 
622
 
 
623
    @needs_read_lock
 
624
    def pending_merges(self):
 
625
        """Return a list of pending merges.
 
626
 
 
627
        These are revisions that have been merged into the working
 
628
        directory but not yet committed.
 
629
        """
 
630
        try:
 
631
            merges_file = self._control_files.get_utf8('pending-merges')
 
632
        except OSError, e:
 
633
            if e.errno != errno.ENOENT:
 
634
                raise
 
635
            return []
 
636
        p = []
 
637
        for l in merges_file.readlines():
 
638
            p.append(l.rstrip('\n'))
 
639
        return p
 
640
 
 
641
    @needs_write_lock
 
642
    def set_pending_merges(self, rev_list):
 
643
        self._control_files.put_utf8('pending-merges', '\n'.join(rev_list))
 
644
 
 
645
    @needs_write_lock
 
646
    def set_merge_modified(self, modified_hashes):
 
647
        def iter_stanzas():
 
648
            for file_id, hash in modified_hashes.iteritems():
 
649
                yield Stanza(file_id=file_id, hash=hash)
 
650
        self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
 
651
 
 
652
    @needs_write_lock
 
653
    def _put_rio(self, filename, stanzas, header):
 
654
        my_file = rio_file(stanzas, header)
 
655
        self._control_files.put(filename, my_file)
 
656
 
 
657
    @needs_read_lock
 
658
    def merge_modified(self):
 
659
        try:
 
660
            hashfile = self._control_files.get('merge-hashes')
 
661
        except NoSuchFile:
 
662
            return {}
 
663
        merge_hashes = {}
 
664
        try:
 
665
            if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
 
666
                raise MergeModifiedFormatError()
 
667
        except StopIteration:
 
668
            raise MergeModifiedFormatError()
 
669
        for s in RioReader(hashfile):
 
670
            file_id = s.get("file_id")
 
671
            if file_id not in self.inventory:
 
672
                continue
 
673
            hash = s.get("hash")
 
674
            if hash == self.get_file_sha1(file_id):
 
675
                merge_hashes[file_id] = hash
 
676
        return merge_hashes
 
677
 
 
678
    def get_symlink_target(self, file_id):
 
679
        return os.readlink(self.id2abspath(file_id))
 
680
 
 
681
    def file_class(self, filename):
 
682
        if self.path2id(filename):
 
683
            return 'V'
 
684
        elif self.is_ignored(filename):
 
685
            return 'I'
 
686
        else:
 
687
            return '?'
 
688
 
 
689
    def list_files(self):
 
690
        """Recursively list all files as (path, class, kind, id).
 
691
 
 
692
        Lists, but does not descend into unversioned directories.
 
693
 
 
694
        This does not include files that have been deleted in this
 
695
        tree.
 
696
 
 
697
        Skips the control directory.
 
698
        """
 
699
        inv = self._inventory
 
700
 
 
701
        def descend(from_dir_relpath, from_dir_id, dp):
 
702
            ls = os.listdir(dp)
 
703
            ls.sort()
 
704
            for f in ls:
 
705
                ## TODO: If we find a subdirectory with its own .bzr
 
706
                ## directory, then that is a separate tree and we
 
707
                ## should exclude it.
 
708
 
 
709
                # the bzrdir for this tree
 
710
                if self.bzrdir.transport.base.endswith(f + '/'):
 
711
                    continue
 
712
 
 
713
                # path within tree
 
714
                fp = appendpath(from_dir_relpath, f)
 
715
 
 
716
                # absolute path
 
717
                fap = appendpath(dp, f)
 
718
                
 
719
                f_ie = inv.get_child(from_dir_id, f)
 
720
                if f_ie:
 
721
                    c = 'V'
 
722
                elif self.is_ignored(fp):
 
723
                    c = 'I'
 
724
                else:
 
725
                    c = '?'
 
726
 
 
727
                fk = file_kind(fap)
 
728
 
 
729
                if f_ie:
 
730
                    if f_ie.kind != fk:
 
731
                        raise BzrCheckError("file %r entered as kind %r id %r, "
 
732
                                            "now of kind %r"
 
733
                                            % (fap, f_ie.kind, f_ie.file_id, fk))
 
734
 
 
735
                # make a last minute entry
 
736
                if f_ie:
 
737
                    entry = f_ie
 
738
                else:
 
739
                    if fk == 'directory':
 
740
                        entry = TreeDirectory()
 
741
                    elif fk == 'file':
 
742
                        entry = TreeFile()
 
743
                    elif fk == 'symlink':
 
744
                        entry = TreeLink()
 
745
                    else:
 
746
                        entry = TreeEntry()
 
747
                
 
748
                yield fp, c, fk, (f_ie and f_ie.file_id), entry
 
749
 
 
750
                if fk != 'directory':
 
751
                    continue
 
752
 
 
753
                if c != 'V':
 
754
                    # don't descend unversioned directories
 
755
                    continue
 
756
                
 
757
                for ff in descend(fp, f_ie.file_id, fap):
 
758
                    yield ff
 
759
 
 
760
        for f in descend(u'', inv.root.file_id, self.basedir):
 
761
            yield f
 
762
 
 
763
    @needs_write_lock
 
764
    def move(self, from_paths, to_name):
 
765
        """Rename files.
 
766
 
 
767
        to_name must exist in the inventory.
 
768
 
 
769
        If to_name exists and is a directory, the files are moved into
 
770
        it, keeping their old names.  
 
771
 
 
772
        Note that to_name is only the last component of the new name;
 
773
        this doesn't change the directory.
 
774
 
 
775
        This returns a list of (from_path, to_path) pairs for each
 
776
        entry that is moved.
 
777
        """
 
778
        result = []
 
779
        ## TODO: Option to move IDs only
 
780
        assert not isinstance(from_paths, basestring)
 
781
        inv = self.inventory
 
782
        to_abs = self.abspath(to_name)
 
783
        if not isdir(to_abs):
 
784
            raise BzrError("destination %r is not a directory" % to_abs)
 
785
        if not self.has_filename(to_name):
 
786
            raise BzrError("destination %r not in working directory" % to_abs)
 
787
        to_dir_id = inv.path2id(to_name)
 
788
        if to_dir_id == None and to_name != '':
 
789
            raise BzrError("destination %r is not a versioned directory" % to_name)
 
790
        to_dir_ie = inv[to_dir_id]
 
791
        if to_dir_ie.kind not in ('directory', 'root_directory'):
 
792
            raise BzrError("destination %r is not a directory" % to_abs)
 
793
 
 
794
        to_idpath = inv.get_idpath(to_dir_id)
 
795
 
 
796
        for f in from_paths:
 
797
            if not self.has_filename(f):
 
798
                raise BzrError("%r does not exist in working tree" % f)
 
799
            f_id = inv.path2id(f)
 
800
            if f_id == None:
 
801
                raise BzrError("%r is not versioned" % f)
 
802
            name_tail = splitpath(f)[-1]
 
803
            dest_path = appendpath(to_name, name_tail)
 
804
            if self.has_filename(dest_path):
 
805
                raise BzrError("destination %r already exists" % dest_path)
 
806
            if f_id in to_idpath:
 
807
                raise BzrError("can't move %r to a subdirectory of itself" % f)
 
808
 
 
809
        # OK, so there's a race here, it's possible that someone will
 
810
        # create a file in this interval and then the rename might be
 
811
        # left half-done.  But we should have caught most problems.
 
812
        orig_inv = deepcopy(self.inventory)
 
813
        try:
 
814
            for f in from_paths:
 
815
                name_tail = splitpath(f)[-1]
 
816
                dest_path = appendpath(to_name, name_tail)
 
817
                result.append((f, dest_path))
 
818
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
819
                try:
 
820
                    rename(self.abspath(f), self.abspath(dest_path))
 
821
                except OSError, e:
 
822
                    raise BzrError("failed to rename %r to %r: %s" %
 
823
                                   (f, dest_path, e[1]),
 
824
                            ["rename rolled back"])
 
825
        except:
 
826
            # restore the inventory on error
 
827
            self._set_inventory(orig_inv)
 
828
            raise
 
829
        self._write_inventory(inv)
 
830
        return result
 
831
 
 
832
    @needs_write_lock
 
833
    def rename_one(self, from_rel, to_rel):
 
834
        """Rename one file.
 
835
 
 
836
        This can change the directory or the filename or both.
 
837
        """
 
838
        inv = self.inventory
 
839
        if not self.has_filename(from_rel):
 
840
            raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
841
        if self.has_filename(to_rel):
 
842
            raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
843
 
 
844
        file_id = inv.path2id(from_rel)
 
845
        if file_id == None:
 
846
            raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
847
 
 
848
        entry = inv[file_id]
 
849
        from_parent = entry.parent_id
 
850
        from_name = entry.name
 
851
        
 
852
        if inv.path2id(to_rel):
 
853
            raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
854
 
 
855
        to_dir, to_tail = os.path.split(to_rel)
 
856
        to_dir_id = inv.path2id(to_dir)
 
857
        if to_dir_id == None and to_dir != '':
 
858
            raise BzrError("can't determine destination directory id for %r" % to_dir)
 
859
 
 
860
        mutter("rename_one:")
 
861
        mutter("  file_id    {%s}" % file_id)
 
862
        mutter("  from_rel   %r" % from_rel)
 
863
        mutter("  to_rel     %r" % to_rel)
 
864
        mutter("  to_dir     %r" % to_dir)
 
865
        mutter("  to_dir_id  {%s}" % to_dir_id)
 
866
 
 
867
        inv.rename(file_id, to_dir_id, to_tail)
 
868
 
 
869
        from_abs = self.abspath(from_rel)
 
870
        to_abs = self.abspath(to_rel)
 
871
        try:
 
872
            rename(from_abs, to_abs)
 
873
        except OSError, e:
 
874
            inv.rename(file_id, from_parent, from_name)
 
875
            raise BzrError("failed to rename %r to %r: %s"
 
876
                    % (from_abs, to_abs, e[1]),
 
877
                    ["rename rolled back"])
 
878
        self._write_inventory(inv)
 
879
 
 
880
    @needs_read_lock
 
881
    def unknowns(self):
 
882
        """Return all unknown files.
 
883
 
 
884
        These are files in the working directory that are not versioned or
 
885
        control files or ignored.
 
886
        
 
887
        >>> from bzrlib.bzrdir import ScratchDir
 
888
        >>> d = ScratchDir(files=['foo', 'foo~'])
 
889
        >>> b = d.open_branch()
 
890
        >>> tree = d.open_workingtree()
 
891
        >>> map(str, tree.unknowns())
 
892
        ['foo']
 
893
        >>> tree.add('foo')
 
894
        >>> list(b.unknowns())
 
895
        []
 
896
        >>> tree.remove('foo')
 
897
        >>> list(b.unknowns())
 
898
        [u'foo']
 
899
        """
 
900
        for subp in self.extras():
 
901
            if not self.is_ignored(subp):
 
902
                yield subp
 
903
 
 
904
    @deprecated_method(zero_eight)
 
905
    def iter_conflicts(self):
 
906
        """List all files in the tree that have text or content conflicts.
 
907
        DEPRECATED.  Use conflicts instead."""
 
908
        return self._iter_conflicts()
 
909
 
 
910
    def _iter_conflicts(self):
 
911
        conflicted = set()
 
912
        for path in (s[0] for s in self.list_files()):
 
913
            stem = get_conflicted_stem(path)
 
914
            if stem is None:
 
915
                continue
 
916
            if stem not in conflicted:
 
917
                conflicted.add(stem)
 
918
                yield stem
 
919
 
 
920
    @needs_write_lock
 
921
    def pull(self, source, overwrite=False, stop_revision=None):
 
922
        top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
923
        source.lock_read()
 
924
        try:
 
925
            pp = ProgressPhase("Pull phase", 2, top_pb)
 
926
            pp.next_phase()
 
927
            old_revision_history = self.branch.revision_history()
 
928
            basis_tree = self.basis_tree()
 
929
            count = self.branch.pull(source, overwrite, stop_revision)
 
930
            new_revision_history = self.branch.revision_history()
 
931
            if new_revision_history != old_revision_history:
 
932
                pp.next_phase()
 
933
                if len(old_revision_history):
 
934
                    other_revision = old_revision_history[-1]
 
935
                else:
 
936
                    other_revision = None
 
937
                repository = self.branch.repository
 
938
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
939
                try:
 
940
                    merge_inner(self.branch,
 
941
                                self.branch.basis_tree(),
 
942
                                basis_tree, 
 
943
                                this_tree=self, 
 
944
                                pb=pb)
 
945
                finally:
 
946
                    pb.finished()
 
947
                self.set_last_revision(self.branch.last_revision())
 
948
            return count
 
949
        finally:
 
950
            source.unlock()
 
951
            top_pb.finished()
 
952
 
 
953
    def extras(self):
 
954
        """Yield all unknown files in this WorkingTree.
 
955
 
 
956
        If there are any unknown directories then only the directory is
 
957
        returned, not all its children.  But if there are unknown files
 
958
        under a versioned subdirectory, they are returned.
 
959
 
 
960
        Currently returned depth-first, sorted by name within directories.
 
961
        """
 
962
        ## TODO: Work from given directory downwards
 
963
        for path, dir_entry in self.inventory.directories():
 
964
            mutter("search for unknowns in %r", path)
 
965
            dirabs = self.abspath(path)
 
966
            if not isdir(dirabs):
 
967
                # e.g. directory deleted
 
968
                continue
 
969
 
 
970
            fl = []
 
971
            for subf in os.listdir(dirabs):
 
972
                if (subf != '.bzr'
 
973
                    and (subf not in dir_entry.children)):
 
974
                    fl.append(subf)
 
975
            
 
976
            fl.sort()
 
977
            for subf in fl:
 
978
                subp = appendpath(path, subf)
 
979
                yield subp
 
980
 
 
981
    def _translate_ignore_rule(self, rule):
 
982
        """Translate a single ignore rule to a regex.
 
983
 
 
984
        There are two types of ignore rules.  Those that do not contain a / are
 
985
        matched against the tail of the filename (that is, they do not care
 
986
        what directory the file is in.)  Rules which do contain a slash must
 
987
        match the entire path.  As a special case, './' at the start of the
 
988
        string counts as a slash in the string but is removed before matching
 
989
        (e.g. ./foo.c, ./src/foo.c)
 
990
 
 
991
        :return: The translated regex.
 
992
        """
 
993
        if rule[:2] in ('./', '.\\'):
 
994
            # rootdir rule
 
995
            result = fnmatch.translate(rule[2:])
 
996
        elif '/' in rule or '\\' in rule:
 
997
            # path prefix 
 
998
            result = fnmatch.translate(rule)
 
999
        else:
 
1000
            # default rule style.
 
1001
            result = "(?:.*/)?(?!.*/)" + fnmatch.translate(rule)
 
1002
        assert result[-1] == '$', "fnmatch.translate did not add the expected $"
 
1003
        return "(" + result + ")"
 
1004
 
 
1005
    def _combine_ignore_rules(self, rules):
 
1006
        """Combine a list of ignore rules into a single regex object.
 
1007
 
 
1008
        Each individual rule is combined with | to form a big regex, which then
 
1009
        has $ added to it to form something like ()|()|()$. The group index for
 
1010
        each subregex's outermost group is placed in a dictionary mapping back 
 
1011
        to the rule. This allows quick identification of the matching rule that
 
1012
        triggered a match.
 
1013
        :return: a list of the compiled regex and the matching-group index 
 
1014
        dictionaries. We return a list because python complains if you try to 
 
1015
        combine more than 100 regexes.
 
1016
        """
 
1017
        result = []
 
1018
        groups = {}
 
1019
        next_group = 0
 
1020
        translated_rules = []
 
1021
        for rule in rules:
 
1022
            translated_rule = self._translate_ignore_rule(rule)
 
1023
            compiled_rule = re.compile(translated_rule)
 
1024
            groups[next_group] = rule
 
1025
            next_group += compiled_rule.groups
 
1026
            translated_rules.append(translated_rule)
 
1027
            if next_group == 99:
 
1028
                result.append((re.compile("|".join(translated_rules)), groups))
 
1029
                groups = {}
 
1030
                next_group = 0
 
1031
                translated_rules = []
 
1032
        if len(translated_rules):
 
1033
            result.append((re.compile("|".join(translated_rules)), groups))
 
1034
        return result
 
1035
 
 
1036
    def ignored_files(self):
 
1037
        """Yield list of PATH, IGNORE_PATTERN"""
 
1038
        for subp in self.extras():
 
1039
            pat = self.is_ignored(subp)
 
1040
            if pat != None:
 
1041
                yield subp, pat
 
1042
 
 
1043
    def get_ignore_list(self):
 
1044
        """Return list of ignore patterns.
 
1045
 
 
1046
        Cached in the Tree object after the first call.
 
1047
        """
 
1048
        if hasattr(self, '_ignorelist'):
 
1049
            return self._ignorelist
 
1050
 
 
1051
        l = bzrlib.DEFAULT_IGNORE[:]
 
1052
        if self.has_filename(bzrlib.IGNORE_FILENAME):
 
1053
            f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
 
1054
            l.extend([line.rstrip("\n\r") for line in f.readlines()])
 
1055
        self._ignorelist = l
 
1056
        self._ignore_regex = self._combine_ignore_rules(l)
 
1057
        return l
 
1058
 
 
1059
    def _get_ignore_rules_as_regex(self):
 
1060
        """Return a regex of the ignore rules and a mapping dict.
 
1061
 
 
1062
        :return: (ignore rules compiled regex, dictionary mapping rule group 
 
1063
        indices to original rule.)
 
1064
        """
 
1065
        if getattr(self, '_ignorelist', None) is None:
 
1066
            self.get_ignore_list()
 
1067
        return self._ignore_regex
 
1068
 
 
1069
    def is_ignored(self, filename):
 
1070
        r"""Check whether the filename matches an ignore pattern.
 
1071
 
 
1072
        Patterns containing '/' or '\' need to match the whole path;
 
1073
        others match against only the last component.
 
1074
 
 
1075
        If the file is ignored, returns the pattern which caused it to
 
1076
        be ignored, otherwise None.  So this can simply be used as a
 
1077
        boolean if desired."""
 
1078
 
 
1079
        # TODO: Use '**' to match directories, and other extended
 
1080
        # globbing stuff from cvs/rsync.
 
1081
 
 
1082
        # XXX: fnmatch is actually not quite what we want: it's only
 
1083
        # approximately the same as real Unix fnmatch, and doesn't
 
1084
        # treat dotfiles correctly and allows * to match /.
 
1085
        # Eventually it should be replaced with something more
 
1086
        # accurate.
 
1087
    
 
1088
        rules = self._get_ignore_rules_as_regex()
 
1089
        for regex, mapping in rules:
 
1090
            match = regex.match(filename)
 
1091
            if match is not None:
 
1092
                # one or more of the groups in mapping will have a non-None group 
 
1093
                # match.
 
1094
                groups = match.groups()
 
1095
                rules = [mapping[group] for group in 
 
1096
                    mapping if groups[group] is not None]
 
1097
                return rules[0]
 
1098
        return None
 
1099
 
 
1100
    def kind(self, file_id):
 
1101
        return file_kind(self.id2abspath(file_id))
 
1102
 
 
1103
    @needs_read_lock
 
1104
    def last_revision(self):
 
1105
        """Return the last revision id of this working tree.
 
1106
 
 
1107
        In early branch formats this was == the branch last_revision,
 
1108
        but that cannot be relied upon - for working tree operations,
 
1109
        always use tree.last_revision().
 
1110
        """
 
1111
        return self.branch.last_revision()
 
1112
 
 
1113
    def is_locked(self):
 
1114
        return self._control_files.is_locked()
 
1115
 
 
1116
    def lock_read(self):
 
1117
        """See Branch.lock_read, and WorkingTree.unlock."""
 
1118
        self.branch.lock_read()
 
1119
        try:
 
1120
            return self._control_files.lock_read()
 
1121
        except:
 
1122
            self.branch.unlock()
 
1123
            raise
 
1124
 
 
1125
    def lock_write(self):
 
1126
        """See Branch.lock_write, and WorkingTree.unlock."""
 
1127
        self.branch.lock_write()
 
1128
        try:
 
1129
            return self._control_files.lock_write()
 
1130
        except:
 
1131
            self.branch.unlock()
 
1132
            raise
 
1133
 
 
1134
    def get_physical_lock_status(self):
 
1135
        return self._control_files.get_physical_lock_status()
 
1136
 
 
1137
    def _basis_inventory_name(self):
 
1138
        return 'basis-inventory'
 
1139
 
 
1140
    @needs_write_lock
 
1141
    def set_last_revision(self, new_revision):
 
1142
        """Change the last revision in the working tree."""
 
1143
        if self._change_last_revision(new_revision):
 
1144
            self._cache_basis_inventory(new_revision)
 
1145
 
 
1146
    def _change_last_revision(self, new_revision):
 
1147
        """Template method part of set_last_revision to perform the change.
 
1148
        
 
1149
        This is used to allow WorkingTree3 instances to not affect branch
 
1150
        when their last revision is set.
 
1151
        """
 
1152
        if new_revision is None:
 
1153
            self.branch.set_revision_history([])
 
1154
            return False
 
1155
        # current format is locked in with the branch
 
1156
        revision_history = self.branch.revision_history()
 
1157
        try:
 
1158
            position = revision_history.index(new_revision)
 
1159
        except ValueError:
 
1160
            raise errors.NoSuchRevision(self.branch, new_revision)
 
1161
        self.branch.set_revision_history(revision_history[:position + 1])
 
1162
        return True
 
1163
 
 
1164
    def _cache_basis_inventory(self, new_revision):
 
1165
        """Cache new_revision as the basis inventory."""
 
1166
        try:
 
1167
            # this double handles the inventory - unpack and repack - 
 
1168
            # but is easier to understand. We can/should put a conditional
 
1169
            # in here based on whether the inventory is in the latest format
 
1170
            # - perhaps we should repack all inventories on a repository
 
1171
            # upgrade ?
 
1172
            inv = self.branch.repository.get_inventory(new_revision)
 
1173
            inv.revision_id = new_revision
 
1174
            xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
 
1175
 
 
1176
            path = self._basis_inventory_name()
 
1177
            self._control_files.put_utf8(path, xml)
 
1178
        except WeaveRevisionNotPresent:
 
1179
            pass
 
1180
 
 
1181
    def read_basis_inventory(self):
 
1182
        """Read the cached basis inventory."""
 
1183
        path = self._basis_inventory_name()
 
1184
        return self._control_files.get_utf8(path).read()
 
1185
        
 
1186
    @needs_read_lock
 
1187
    def read_working_inventory(self):
 
1188
        """Read the working inventory."""
 
1189
        # ElementTree does its own conversion from UTF-8, so open in
 
1190
        # binary.
 
1191
        result = bzrlib.xml5.serializer_v5.read_inventory(
 
1192
            self._control_files.get('inventory'))
 
1193
        self._set_inventory(result)
 
1194
        return result
 
1195
 
 
1196
    @needs_write_lock
 
1197
    def remove(self, files, verbose=False):
 
1198
        """Remove nominated files from the working inventory..
 
1199
 
 
1200
        This does not remove their text.  This does not run on XXX on what? RBC
 
1201
 
 
1202
        TODO: Refuse to remove modified files unless --force is given?
 
1203
 
 
1204
        TODO: Do something useful with directories.
 
1205
 
 
1206
        TODO: Should this remove the text or not?  Tough call; not
 
1207
        removing may be useful and the user can just use use rm, and
 
1208
        is the opposite of add.  Removing it is consistent with most
 
1209
        other tools.  Maybe an option.
 
1210
        """
 
1211
        ## TODO: Normalize names
 
1212
        ## TODO: Remove nested loops; better scalability
 
1213
        if isinstance(files, basestring):
 
1214
            files = [files]
 
1215
 
 
1216
        inv = self.inventory
 
1217
 
 
1218
        # do this before any modifications
 
1219
        for f in files:
 
1220
            fid = inv.path2id(f)
 
1221
            if not fid:
 
1222
                # TODO: Perhaps make this just a warning, and continue?
 
1223
                # This tends to happen when 
 
1224
                raise NotVersionedError(path=f)
 
1225
            mutter("remove inventory entry %s {%s}", quotefn(f), fid)
 
1226
            if verbose:
 
1227
                # having remove it, it must be either ignored or unknown
 
1228
                if self.is_ignored(f):
 
1229
                    new_status = 'I'
 
1230
                else:
 
1231
                    new_status = '?'
 
1232
                show_status(new_status, inv[fid].kind, quotefn(f))
 
1233
            del inv[fid]
 
1234
 
 
1235
        self._write_inventory(inv)
 
1236
 
 
1237
    @needs_write_lock
 
1238
    def revert(self, filenames, old_tree=None, backups=True, 
 
1239
               pb=DummyProgress()):
 
1240
        from transform import revert
 
1241
        from conflicts import resolve
 
1242
        if old_tree is None:
 
1243
            old_tree = self.basis_tree()
 
1244
        conflicts = revert(self, old_tree, filenames, backups, pb)
 
1245
        if not len(filenames):
 
1246
            self.set_pending_merges([])
 
1247
            resolve(self)
 
1248
        else:
 
1249
            resolve(self, filenames, ignore_misses=True)
 
1250
        return conflicts
 
1251
 
 
1252
    # XXX: This method should be deprecated in favour of taking in a proper
 
1253
    # new Inventory object.
 
1254
    @needs_write_lock
 
1255
    def set_inventory(self, new_inventory_list):
 
1256
        from bzrlib.inventory import (Inventory,
 
1257
                                      InventoryDirectory,
 
1258
                                      InventoryEntry,
 
1259
                                      InventoryFile,
 
1260
                                      InventoryLink)
 
1261
        inv = Inventory(self.get_root_id())
 
1262
        for path, file_id, parent, kind in new_inventory_list:
 
1263
            name = os.path.basename(path)
 
1264
            if name == "":
 
1265
                continue
 
1266
            # fixme, there should be a factory function inv,add_?? 
 
1267
            if kind == 'directory':
 
1268
                inv.add(InventoryDirectory(file_id, name, parent))
 
1269
            elif kind == 'file':
 
1270
                inv.add(InventoryFile(file_id, name, parent))
 
1271
            elif kind == 'symlink':
 
1272
                inv.add(InventoryLink(file_id, name, parent))
 
1273
            else:
 
1274
                raise BzrError("unknown kind %r" % kind)
 
1275
        self._write_inventory(inv)
 
1276
 
 
1277
    @needs_write_lock
 
1278
    def set_root_id(self, file_id):
 
1279
        """Set the root id for this tree."""
 
1280
        inv = self.read_working_inventory()
 
1281
        orig_root_id = inv.root.file_id
 
1282
        del inv._byid[inv.root.file_id]
 
1283
        inv.root.file_id = file_id
 
1284
        inv._byid[inv.root.file_id] = inv.root
 
1285
        for fid in inv:
 
1286
            entry = inv[fid]
 
1287
            if entry.parent_id == orig_root_id:
 
1288
                entry.parent_id = inv.root.file_id
 
1289
        self._write_inventory(inv)
 
1290
 
 
1291
    def unlock(self):
 
1292
        """See Branch.unlock.
 
1293
        
 
1294
        WorkingTree locking just uses the Branch locking facilities.
 
1295
        This is current because all working trees have an embedded branch
 
1296
        within them. IF in the future, we were to make branch data shareable
 
1297
        between multiple working trees, i.e. via shared storage, then we 
 
1298
        would probably want to lock both the local tree, and the branch.
 
1299
        """
 
1300
        # FIXME: We want to write out the hashcache only when the last lock on
 
1301
        # this working copy is released.  Peeking at the lock count is a bit
 
1302
        # of a nasty hack; probably it's better to have a transaction object,
 
1303
        # which can do some finalization when it's either successfully or
 
1304
        # unsuccessfully completed.  (Denys's original patch did that.)
 
1305
        # RBC 20060206 hookinhg into transaction will couple lock and transaction
 
1306
        # wrongly. Hookinh into unllock on the control files object is fine though.
 
1307
        
 
1308
        # TODO: split this per format so there is no ugly if block
 
1309
        if self._hashcache.needs_write and (
 
1310
            # dedicated lock files
 
1311
            self._control_files._lock_count==1 or 
 
1312
            # shared lock files
 
1313
            (self._control_files is self.branch.control_files and 
 
1314
             self._control_files._lock_count==3)):
 
1315
            self._hashcache.write()
 
1316
        # reverse order of locking.
 
1317
        try:
 
1318
            return self._control_files.unlock()
 
1319
        finally:
 
1320
            self.branch.unlock()
 
1321
 
 
1322
    @needs_write_lock
 
1323
    def update(self):
 
1324
        """Update a working tree along its branch.
 
1325
 
 
1326
        This will update the branch if its bound too, which means we have multiple trees involved:
 
1327
        The new basis tree of the master.
 
1328
        The old basis tree of the branch.
 
1329
        The old basis tree of the working tree.
 
1330
        The current working tree state.
 
1331
        pathologically all three may be different, and non ancestors of each other.
 
1332
        Conceptually we want to:
 
1333
        Preserve the wt.basis->wt.state changes
 
1334
        Transform the wt.basis to the new master basis.
 
1335
        Apply a merge of the old branch basis to get any 'local' changes from it into the tree.
 
1336
        Restore the wt.basis->wt.state changes.
 
1337
 
 
1338
        There isn't a single operation at the moment to do that, so we:
 
1339
        Merge current state -> basis tree of the master w.r.t. the old tree basis.
 
1340
        Do a 'normal' merge of the old branch basis if it is relevant.
 
1341
        """
 
1342
        old_tip = self.branch.update()
 
1343
        if old_tip is not None:
 
1344
            self.add_pending_merge(old_tip)
 
1345
        self.branch.lock_read()
 
1346
        try:
 
1347
            result = 0
 
1348
            if self.last_revision() != self.branch.last_revision():
 
1349
                # merge tree state up to new branch tip.
 
1350
                basis = self.basis_tree()
 
1351
                to_tree = self.branch.basis_tree()
 
1352
                result += merge_inner(self.branch,
 
1353
                                      to_tree,
 
1354
                                      basis,
 
1355
                                      this_tree=self)
 
1356
                self.set_last_revision(self.branch.last_revision())
 
1357
            if old_tip and old_tip != self.last_revision():
 
1358
                # our last revision was not the prior branch last reivison
 
1359
                # and we have converted that last revision to a pending merge.
 
1360
                # base is somewhere between the branch tip now
 
1361
                # and the now pending merge
 
1362
                from bzrlib.revision import common_ancestor
 
1363
                try:
 
1364
                    base_rev_id = common_ancestor(self.branch.last_revision(),
 
1365
                                                  old_tip,
 
1366
                                                  self.branch.repository)
 
1367
                except errors.NoCommonAncestor:
 
1368
                    base_rev_id = None
 
1369
                base_tree = self.branch.repository.revision_tree(base_rev_id)
 
1370
                other_tree = self.branch.repository.revision_tree(old_tip)
 
1371
                result += merge_inner(self.branch,
 
1372
                                      other_tree,
 
1373
                                      base_tree,
 
1374
                                      this_tree=self)
 
1375
            return result
 
1376
        finally:
 
1377
            self.branch.unlock()
 
1378
 
 
1379
    @needs_write_lock
 
1380
    def _write_inventory(self, inv):
 
1381
        """Write inventory as the current inventory."""
 
1382
        sio = StringIO()
 
1383
        bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
 
1384
        sio.seek(0)
 
1385
        self._control_files.put('inventory', sio)
 
1386
        self._set_inventory(inv)
 
1387
        mutter('wrote working inventory')
 
1388
 
 
1389
    def set_conflicts(self, arg):
 
1390
        raise UnsupportedOperation(self.set_conflicts, self)
 
1391
 
 
1392
    @needs_read_lock
 
1393
    def conflicts(self):
 
1394
        conflicts = ConflictList()
 
1395
        for conflicted in self._iter_conflicts():
 
1396
            text = True
 
1397
            try:
 
1398
                if file_kind(self.abspath(conflicted)) != "file":
 
1399
                    text = False
 
1400
            except OSError, e:
 
1401
                if e.errno == errno.ENOENT:
 
1402
                    text = False
 
1403
                else:
 
1404
                    raise
 
1405
            if text is True:
 
1406
                for suffix in ('.THIS', '.OTHER'):
 
1407
                    try:
 
1408
                        kind = file_kind(self.abspath(conflicted+suffix))
 
1409
                    except OSError, e:
 
1410
                        if e.errno == errno.ENOENT:
 
1411
                            text = False
 
1412
                            break
 
1413
                        else:
 
1414
                            raise
 
1415
                    if kind != "file":
 
1416
                        text = False
 
1417
                        break
 
1418
            ctype = {True: 'text conflict', False: 'contents conflict'}[text]
 
1419
            conflicts.append(Conflict.factory(ctype, path=conflicted,
 
1420
                             file_id=self.path2id(conflicted)))
 
1421
        return conflicts
 
1422
 
 
1423
 
 
1424
class WorkingTree3(WorkingTree):
 
1425
    """This is the Format 3 working tree.
 
1426
 
 
1427
    This differs from the base WorkingTree by:
 
1428
     - having its own file lock
 
1429
     - having its own last-revision property.
 
1430
 
 
1431
    This is new in bzr 0.8
 
1432
    """
 
1433
 
 
1434
    @needs_read_lock
 
1435
    def last_revision(self):
 
1436
        """See WorkingTree.last_revision."""
 
1437
        try:
 
1438
            return self._control_files.get_utf8('last-revision').read()
 
1439
        except NoSuchFile:
 
1440
            return None
 
1441
 
 
1442
    def _change_last_revision(self, revision_id):
 
1443
        """See WorkingTree._change_last_revision."""
 
1444
        if revision_id is None or revision_id == NULL_REVISION:
 
1445
            try:
 
1446
                self._control_files._transport.delete('last-revision')
 
1447
            except errors.NoSuchFile:
 
1448
                pass
 
1449
            return False
 
1450
        else:
 
1451
            try:
 
1452
                self.branch.revision_history().index(revision_id)
 
1453
            except ValueError:
 
1454
                raise errors.NoSuchRevision(self.branch, revision_id)
 
1455
            self._control_files.put_utf8('last-revision', revision_id)
 
1456
            return True
 
1457
 
 
1458
    @needs_write_lock
 
1459
    def set_conflicts(self, conflicts):
 
1460
        self._put_rio('conflicts', conflicts.to_stanzas(), 
 
1461
                      CONFLICT_HEADER_1)
 
1462
 
 
1463
    @needs_read_lock
 
1464
    def conflicts(self):
 
1465
        try:
 
1466
            confile = self._control_files.get('conflicts')
 
1467
        except NoSuchFile:
 
1468
            return ConflictList()
 
1469
        try:
 
1470
            if confile.next() != CONFLICT_HEADER_1 + '\n':
 
1471
                raise ConflictFormatError()
 
1472
        except StopIteration:
 
1473
            raise ConflictFormatError()
 
1474
        return ConflictList.from_stanzas(RioReader(confile))
 
1475
 
 
1476
 
 
1477
def get_conflicted_stem(path):
 
1478
    for suffix in CONFLICT_SUFFIXES:
 
1479
        if path.endswith(suffix):
 
1480
            return path[:-len(suffix)]
 
1481
 
 
1482
@deprecated_function(zero_eight)
 
1483
def is_control_file(filename):
 
1484
    """See WorkingTree.is_control_filename(filename)."""
 
1485
    ## FIXME: better check
 
1486
    filename = normpath(filename)
 
1487
    while filename != '':
 
1488
        head, tail = os.path.split(filename)
 
1489
        ## mutter('check %r for control file' % ((head, tail),))
 
1490
        if tail == '.bzr':
 
1491
            return True
 
1492
        if filename == head:
 
1493
            break
 
1494
        filename = head
 
1495
    return False
 
1496
 
 
1497
 
 
1498
class WorkingTreeFormat(object):
 
1499
    """An encapsulation of the initialization and open routines for a format.
 
1500
 
 
1501
    Formats provide three things:
 
1502
     * An initialization routine,
 
1503
     * a format string,
 
1504
     * an open routine.
 
1505
 
 
1506
    Formats are placed in an dict by their format string for reference 
 
1507
    during workingtree opening. Its not required that these be instances, they
 
1508
    can be classes themselves with class methods - it simply depends on 
 
1509
    whether state is needed for a given format or not.
 
1510
 
 
1511
    Once a format is deprecated, just deprecate the initialize and open
 
1512
    methods on the format class. Do not deprecate the object, as the 
 
1513
    object will be created every time regardless.
 
1514
    """
 
1515
 
 
1516
    _default_format = None
 
1517
    """The default format used for new trees."""
 
1518
 
 
1519
    _formats = {}
 
1520
    """The known formats."""
 
1521
 
 
1522
    @classmethod
 
1523
    def find_format(klass, a_bzrdir):
 
1524
        """Return the format for the working tree object in a_bzrdir."""
 
1525
        try:
 
1526
            transport = a_bzrdir.get_workingtree_transport(None)
 
1527
            format_string = transport.get("format").read()
 
1528
            return klass._formats[format_string]
 
1529
        except NoSuchFile:
 
1530
            raise errors.NoWorkingTree(base=transport.base)
 
1531
        except KeyError:
 
1532
            raise errors.UnknownFormatError(format_string)
 
1533
 
 
1534
    @classmethod
 
1535
    def get_default_format(klass):
 
1536
        """Return the current default format."""
 
1537
        return klass._default_format
 
1538
 
 
1539
    def get_format_string(self):
 
1540
        """Return the ASCII format string that identifies this format."""
 
1541
        raise NotImplementedError(self.get_format_string)
 
1542
 
 
1543
    def get_format_description(self):
 
1544
        """Return the short description for this format."""
 
1545
        raise NotImplementedError(self.get_format_description)
 
1546
 
 
1547
    def is_supported(self):
 
1548
        """Is this format supported?
 
1549
 
 
1550
        Supported formats can be initialized and opened.
 
1551
        Unsupported formats may not support initialization or committing or 
 
1552
        some other features depending on the reason for not being supported.
 
1553
        """
 
1554
        return True
 
1555
 
 
1556
    @classmethod
 
1557
    def register_format(klass, format):
 
1558
        klass._formats[format.get_format_string()] = format
 
1559
 
 
1560
    @classmethod
 
1561
    def set_default_format(klass, format):
 
1562
        klass._default_format = format
 
1563
 
 
1564
    @classmethod
 
1565
    def unregister_format(klass, format):
 
1566
        assert klass._formats[format.get_format_string()] is format
 
1567
        del klass._formats[format.get_format_string()]
 
1568
 
 
1569
 
 
1570
 
 
1571
class WorkingTreeFormat2(WorkingTreeFormat):
 
1572
    """The second working tree format. 
 
1573
 
 
1574
    This format modified the hash cache from the format 1 hash cache.
 
1575
    """
 
1576
 
 
1577
    def get_format_description(self):
 
1578
        """See WorkingTreeFormat.get_format_description()."""
 
1579
        return "Working tree format 2"
 
1580
 
 
1581
    def stub_initialize_remote(self, control_files):
 
1582
        """As a special workaround create critical control files for a remote working tree
 
1583
        
 
1584
        This ensures that it can later be updated and dealt with locally,
 
1585
        since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with 
 
1586
        no working tree.  (See bug #43064).
 
1587
        """
 
1588
        sio = StringIO()
 
1589
        inv = Inventory()
 
1590
        bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
 
1591
        sio.seek(0)
 
1592
        control_files.put('inventory', sio)
 
1593
 
 
1594
        control_files.put_utf8('pending-merges', '')
 
1595
        
 
1596
 
 
1597
    def initialize(self, a_bzrdir, revision_id=None):
 
1598
        """See WorkingTreeFormat.initialize()."""
 
1599
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1600
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1601
        branch = a_bzrdir.open_branch()
 
1602
        if revision_id is not None:
 
1603
            branch.lock_write()
 
1604
            try:
 
1605
                revision_history = branch.revision_history()
 
1606
                try:
 
1607
                    position = revision_history.index(revision_id)
 
1608
                except ValueError:
 
1609
                    raise errors.NoSuchRevision(branch, revision_id)
 
1610
                branch.set_revision_history(revision_history[:position + 1])
 
1611
            finally:
 
1612
                branch.unlock()
 
1613
        revision = branch.last_revision()
 
1614
        inv = Inventory() 
 
1615
        wt = WorkingTree(a_bzrdir.root_transport.base,
 
1616
                         branch,
 
1617
                         inv,
 
1618
                         _internal=True,
 
1619
                         _format=self,
 
1620
                         _bzrdir=a_bzrdir)
 
1621
        wt._write_inventory(inv)
 
1622
        wt.set_root_id(inv.root.file_id)
 
1623
        wt.set_last_revision(revision)
 
1624
        wt.set_pending_merges([])
 
1625
        build_tree(wt.basis_tree(), wt)
 
1626
        return wt
 
1627
 
 
1628
    def __init__(self):
 
1629
        super(WorkingTreeFormat2, self).__init__()
 
1630
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
 
1631
 
 
1632
    def open(self, a_bzrdir, _found=False):
 
1633
        """Return the WorkingTree object for a_bzrdir
 
1634
 
 
1635
        _found is a private parameter, do not use it. It is used to indicate
 
1636
               if format probing has already been done.
 
1637
        """
 
1638
        if not _found:
 
1639
            # we are being called directly and must probe.
 
1640
            raise NotImplementedError
 
1641
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1642
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1643
        return WorkingTree(a_bzrdir.root_transport.base,
 
1644
                           _internal=True,
 
1645
                           _format=self,
 
1646
                           _bzrdir=a_bzrdir)
 
1647
 
 
1648
 
 
1649
class WorkingTreeFormat3(WorkingTreeFormat):
 
1650
    """The second working tree format updated to record a format marker.
 
1651
 
 
1652
    This format:
 
1653
        - exists within a metadir controlling .bzr
 
1654
        - includes an explicit version marker for the workingtree control
 
1655
          files, separate from the BzrDir format
 
1656
        - modifies the hash cache format
 
1657
        - is new in bzr 0.8
 
1658
        - uses a LockDir to guard access to the repository
 
1659
    """
 
1660
 
 
1661
    def get_format_string(self):
 
1662
        """See WorkingTreeFormat.get_format_string()."""
 
1663
        return "Bazaar-NG Working Tree format 3"
 
1664
 
 
1665
    def get_format_description(self):
 
1666
        """See WorkingTreeFormat.get_format_description()."""
 
1667
        return "Working tree format 3"
 
1668
 
 
1669
    _lock_file_name = 'lock'
 
1670
    _lock_class = LockDir
 
1671
 
 
1672
    def _open_control_files(self, a_bzrdir):
 
1673
        transport = a_bzrdir.get_workingtree_transport(None)
 
1674
        return LockableFiles(transport, self._lock_file_name, 
 
1675
                             self._lock_class)
 
1676
 
 
1677
    def initialize(self, a_bzrdir, revision_id=None):
 
1678
        """See WorkingTreeFormat.initialize().
 
1679
        
 
1680
        revision_id allows creating a working tree at a differnet
 
1681
        revision than the branch is at.
 
1682
        """
 
1683
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1684
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1685
        transport = a_bzrdir.get_workingtree_transport(self)
 
1686
        control_files = self._open_control_files(a_bzrdir)
 
1687
        control_files.create_lock()
 
1688
        control_files.lock_write()
 
1689
        control_files.put_utf8('format', self.get_format_string())
 
1690
        branch = a_bzrdir.open_branch()
 
1691
        if revision_id is None:
 
1692
            revision_id = branch.last_revision()
 
1693
        inv = Inventory() 
 
1694
        wt = WorkingTree3(a_bzrdir.root_transport.base,
 
1695
                         branch,
 
1696
                         inv,
 
1697
                         _internal=True,
 
1698
                         _format=self,
 
1699
                         _bzrdir=a_bzrdir,
 
1700
                         _control_files=control_files)
 
1701
        wt.lock_write()
 
1702
        try:
 
1703
            wt._write_inventory(inv)
 
1704
            wt.set_root_id(inv.root.file_id)
 
1705
            wt.set_last_revision(revision_id)
 
1706
            wt.set_pending_merges([])
 
1707
            build_tree(wt.basis_tree(), wt)
 
1708
        finally:
 
1709
            wt.unlock()
 
1710
            control_files.unlock()
 
1711
        return wt
 
1712
 
 
1713
    def __init__(self):
 
1714
        super(WorkingTreeFormat3, self).__init__()
 
1715
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1716
 
 
1717
    def open(self, a_bzrdir, _found=False):
 
1718
        """Return the WorkingTree object for a_bzrdir
 
1719
 
 
1720
        _found is a private parameter, do not use it. It is used to indicate
 
1721
               if format probing has already been done.
 
1722
        """
 
1723
        if not _found:
 
1724
            # we are being called directly and must probe.
 
1725
            raise NotImplementedError
 
1726
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1727
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1728
        control_files = self._open_control_files(a_bzrdir)
 
1729
        return WorkingTree3(a_bzrdir.root_transport.base,
 
1730
                           _internal=True,
 
1731
                           _format=self,
 
1732
                           _bzrdir=a_bzrdir,
 
1733
                           _control_files=control_files)
 
1734
 
 
1735
    def __str__(self):
 
1736
        return self.get_format_string()
 
1737
 
 
1738
 
 
1739
# formats which have no format string are not discoverable
 
1740
# and not independently creatable, so are not registered.
 
1741
__default_format = WorkingTreeFormat3()
 
1742
WorkingTreeFormat.register_format(__default_format)
 
1743
WorkingTreeFormat.set_default_format(__default_format)
 
1744
_legacy_formats = [WorkingTreeFormat2(),
 
1745
                   ]
 
1746
 
 
1747
 
 
1748
class WorkingTreeTestProviderAdapter(object):
 
1749
    """A tool to generate a suite testing multiple workingtree formats at once.
 
1750
 
 
1751
    This is done by copying the test once for each transport and injecting
 
1752
    the transport_server, transport_readonly_server, and workingtree_format
 
1753
    classes into each copy. Each copy is also given a new id() to make it
 
1754
    easy to identify.
 
1755
    """
 
1756
 
 
1757
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1758
        self._transport_server = transport_server
 
1759
        self._transport_readonly_server = transport_readonly_server
 
1760
        self._formats = formats
 
1761
    
 
1762
    def adapt(self, test):
 
1763
        from bzrlib.tests import TestSuite
 
1764
        result = TestSuite()
 
1765
        for workingtree_format, bzrdir_format in self._formats:
 
1766
            new_test = deepcopy(test)
 
1767
            new_test.transport_server = self._transport_server
 
1768
            new_test.transport_readonly_server = self._transport_readonly_server
 
1769
            new_test.bzrdir_format = bzrdir_format
 
1770
            new_test.workingtree_format = workingtree_format
 
1771
            def make_new_test_id():
 
1772
                new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
 
1773
                return lambda: new_id
 
1774
            new_test.id = make_new_test_id()
 
1775
            result.addTest(new_test)
 
1776
        return result