← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-02-18 02:33:47 UTC
  • mfrom: (1534.1.24 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060218023347-0952c65f668bfd68
Merge Robert Collins integration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
# TODO: Don't allow WorkingTrees to be constructed for remote branches.
 
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
 
18
32
 
19
33
# FIXME: I don't know if writing out the cache from the destructor is really a
20
 
# good idea, because destructors are considered poor taste in Python, and
21
 
# it's not predictable when it will be written out.
22
 
 
 
34
# good idea, because destructors are considered poor taste in Python, and it's
 
35
# not predictable when it will be written out.
 
36
 
 
37
# TODO: Give the workingtree sole responsibility for the working inventory;
 
38
# remove the variable and references to it from the branch.  This may require
 
39
# updating the commit code so as to update the inventory within the working
 
40
# copy, and making sure there's only one WorkingTree for any directory on disk.
 
41
# At the momenthey may alias the inventory and have old copies of it in memory.
 
42
 
 
43
from copy import deepcopy
 
44
from cStringIO import StringIO
 
45
import errno
 
46
import fnmatch
23
47
import os
24
48
import stat
25
 
import fnmatch
26
 
        
 
49
 
 
50
 
 
51
from bzrlib.atomicfile import AtomicFile
 
52
from bzrlib.branch import (Branch,
 
53
                           quotefn)
 
54
import bzrlib.bzrdir as bzrdir
 
55
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
56
import bzrlib.errors as errors
 
57
from bzrlib.errors import (BzrCheckError,
 
58
                           BzrError,
 
59
                           DivergedBranches,
 
60
                           WeaveRevisionNotPresent,
 
61
                           NotBranchError,
 
62
                           NoSuchFile,
 
63
                           NotVersionedError)
 
64
from bzrlib.inventory import InventoryEntry
 
65
from bzrlib.lockable_files import LockableFiles
 
66
from bzrlib.merge import merge_inner, transform_tree
 
67
from bzrlib.osutils import (appendpath,
 
68
                            compact_date,
 
69
                            file_kind,
 
70
                            isdir,
 
71
                            getcwd,
 
72
                            pathjoin,
 
73
                            pumpfile,
 
74
                            safe_unicode,
 
75
                            splitpath,
 
76
                            rand_bytes,
 
77
                            abspath,
 
78
                            normpath,
 
79
                            realpath,
 
80
                            relpath,
 
81
                            rename)
 
82
from bzrlib.revision import NULL_REVISION
 
83
from bzrlib.symbol_versioning import *
 
84
from bzrlib.textui import show_status
27
85
import bzrlib.tree
28
 
from bzrlib.osutils import appendpath, file_kind, isdir, splitpath
29
 
from bzrlib.errors import BzrCheckError
30
86
from bzrlib.trace import mutter
 
87
from bzrlib.transport import get_transport
 
88
from bzrlib.transport.local import LocalTransport
 
89
import bzrlib.xml5
 
90
 
 
91
 
 
92
def gen_file_id(name):
 
93
    """Return new file id.
 
94
 
 
95
    This should probably generate proper UUIDs, but for the moment we
 
96
    cope with just randomness because running uuidgen every time is
 
97
    slow."""
 
98
    import re
 
99
    from binascii import hexlify
 
100
    from time import time
 
101
 
 
102
    # get last component
 
103
    idx = name.rfind('/')
 
104
    if idx != -1:
 
105
        name = name[idx+1 : ]
 
106
    idx = name.rfind('\\')
 
107
    if idx != -1:
 
108
        name = name[idx+1 : ]
 
109
 
 
110
    # make it not a hidden file
 
111
    name = name.lstrip('.')
 
112
 
 
113
    # remove any wierd characters; we don't escape them but rather
 
114
    # just pull them out
 
115
    name = re.sub(r'[^\w.]', '', name)
 
116
 
 
117
    s = hexlify(rand_bytes(8))
 
118
    return '-'.join((name, compact_date(time()), s))
 
119
 
 
120
 
 
121
def gen_root_id():
 
122
    """Return a new tree-root file id."""
 
123
    return gen_file_id('TREE_ROOT')
 
124
 
31
125
 
32
126
class TreeEntry(object):
33
127
    """An entry that implements the minium interface used by commands.
93
187
    It is possible for a `WorkingTree` to have a filename which is
94
188
    not listed in the Inventory and vice versa.
95
189
    """
96
 
    def __init__(self, basedir, inv):
 
190
 
 
191
    def __init__(self, basedir='.',
 
192
                 branch=DEPRECATED_PARAMETER,
 
193
                 _inventory=None,
 
194
                 _control_files=None,
 
195
                 _internal=False,
 
196
                 _format=None,
 
197
                 _bzrdir=None):
 
198
        """Construct a WorkingTree for basedir.
 
199
 
 
200
        If the branch is not supplied, it is opened automatically.
 
201
        If the branch is supplied, it must be the branch for this basedir.
 
202
        (branch.base is not cross checked, because for remote branches that
 
203
        would be meaningless).
 
204
        """
 
205
        self._format = _format
 
206
        self.bzrdir = _bzrdir
 
207
        if not _internal:
 
208
            # not created via open etc.
 
209
            warn("WorkingTree() is deprecated as of bzr version 0.8. "
 
210
                 "Please use bzrdir.open_workingtree or WorkingTree.open().",
 
211
                 DeprecationWarning,
 
212
                 stacklevel=2)
 
213
            wt = WorkingTree.open(basedir)
 
214
            self.branch = wt.branch
 
215
            self.basedir = wt.basedir
 
216
            self._control_files = wt._control_files
 
217
            self._hashcache = wt._hashcache
 
218
            self._set_inventory(wt._inventory)
 
219
            self._format = wt._format
 
220
            self.bzrdir = wt.bzrdir
97
221
        from bzrlib.hashcache import HashCache
98
222
        from bzrlib.trace import note, mutter
99
 
 
100
 
        self._inventory = inv
101
 
        self.basedir = basedir
102
 
        self.path2id = inv.path2id
 
223
        assert isinstance(basedir, basestring), \
 
224
            "base directory %r is not a string" % basedir
 
225
        basedir = safe_unicode(basedir)
 
226
        mutter("opening working tree %r", basedir)
 
227
        if deprecated_passed(branch):
 
228
            if not _internal:
 
229
                warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
 
230
                     " Please use bzrdir.open_workingtree() or WorkingTree.open().",
 
231
                     DeprecationWarning,
 
232
                     stacklevel=2
 
233
                     )
 
234
            self.branch = branch
 
235
        else:
 
236
            self.branch = self.bzrdir.open_branch()
 
237
        assert isinstance(self.branch, Branch), \
 
238
            "branch %r is not a Branch" % self.branch
 
239
        self.basedir = realpath(basedir)
 
240
        # if branch is at our basedir and is a format 6 or less
 
241
        if isinstance(self._format, WorkingTreeFormat2):
 
242
            # share control object
 
243
            self._control_files = self.branch.control_files
 
244
        elif _control_files is not None:
 
245
            assert False, "not done yet"
 
246
#            self._control_files = _control_files
 
247
        else:
 
248
            # only ready for format 3
 
249
            assert isinstance(self._format, WorkingTreeFormat3)
 
250
            self._control_files = LockableFiles(
 
251
                self.bzrdir.get_workingtree_transport(None),
 
252
                'lock')
103
253
 
104
254
        # update the whole cache up front and write to disk if anything changed;
105
255
        # in the future we might want to do this more selectively
106
 
        hc = self._hashcache = HashCache(basedir)
 
256
        # two possible ways offer themselves : in self._unlock, write the cache
 
257
        # if needed, or, when the cache sees a change, append it to the hash
 
258
        # cache file, and have the parser take the most recent entry for a
 
259
        # given path only.
 
260
        cache_filename = self.bzrdir.get_workingtree_transport(None).abspath('stat-cache')
 
261
        hc = self._hashcache = HashCache(basedir, cache_filename, self._control_files._file_mode)
107
262
        hc.read()
 
263
        # is this scan needed ? it makes things kinda slow.
108
264
        hc.scan()
109
265
 
110
266
        if hc.needs_write:
111
267
            mutter("write hc")
112
268
            hc.write()
113
 
            
114
 
            
115
 
    def __del__(self):
116
 
        if self._hashcache.needs_write:
117
 
            self._hashcache.write()
118
 
 
 
269
 
 
270
        if _inventory is None:
 
271
            self._set_inventory(self.read_working_inventory())
 
272
        else:
 
273
            self._set_inventory(_inventory)
 
274
 
 
275
    def _set_inventory(self, inv):
 
276
        self._inventory = inv
 
277
        self.path2id = self._inventory.path2id
 
278
 
 
279
    def is_control_filename(self, filename):
 
280
        """True if filename is the name of a control file in this tree.
 
281
        
 
282
        This is true IF and ONLY IF the filename is part of the meta data
 
283
        that bzr controls in this tree. I.E. a random .bzr directory placed
 
284
        on disk will not be a control file for this tree.
 
285
        """
 
286
        try:
 
287
            self.bzrdir.transport.relpath(self.abspath(filename))
 
288
            return True
 
289
        except errors.PathNotChild:
 
290
            return False
 
291
 
 
292
    @staticmethod
 
293
    def open(path=None, _unsupported=False):
 
294
        """Open an existing working tree at path.
 
295
 
 
296
        """
 
297
        if path is None:
 
298
            path = os.path.getcwdu()
 
299
        control = bzrdir.BzrDir.open(path, _unsupported)
 
300
        return control.open_workingtree(_unsupported)
 
301
        
 
302
    @staticmethod
 
303
    def open_containing(path=None):
 
304
        """Open an existing working tree which has its root about path.
 
305
        
 
306
        This probes for a working tree at path and searches upwards from there.
 
307
 
 
308
        Basically we keep looking up until we find the control directory or
 
309
        run into /.  If there isn't one, raises NotBranchError.
 
310
        TODO: give this a new exception.
 
311
        If there is one, it is returned, along with the unused portion of path.
 
312
        """
 
313
        if path is None:
 
314
            path = os.getcwdu()
 
315
        control, relpath = bzrdir.BzrDir.open_containing(path)
 
316
        return control.open_workingtree(), relpath
 
317
 
 
318
    @staticmethod
 
319
    def open_downlevel(path=None):
 
320
        """Open an unsupported working tree.
 
321
 
 
322
        Only intended for advanced situations like upgrading part of a bzrdir.
 
323
        """
 
324
        return WorkingTree.open(path, _unsupported=True)
119
325
 
120
326
    def __iter__(self):
121
327
        """Iterate through file_ids for this tree.
128
334
            if bzrlib.osutils.lexists(self.abspath(path)):
129
335
                yield ie.file_id
130
336
 
131
 
 
132
337
    def __repr__(self):
133
338
        return "<%s of %s>" % (self.__class__.__name__,
134
339
                               getattr(self, 'basedir', None))
135
340
 
136
 
 
137
 
 
138
341
    def abspath(self, filename):
139
 
        return os.path.join(self.basedir, filename)
 
342
        return pathjoin(self.basedir, filename)
 
343
    
 
344
    def basis_tree(self):
 
345
        """Return RevisionTree for the current last revision."""
 
346
        revision_id = self.last_revision()
 
347
        if revision_id is not None:
 
348
            try:
 
349
                xml = self.read_basis_inventory(revision_id)
 
350
                inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
351
                return bzrlib.tree.RevisionTree(self.branch.repository, inv,
 
352
                                                revision_id)
 
353
            except NoSuchFile:
 
354
                pass
 
355
        return self.branch.repository.revision_tree(revision_id)
 
356
 
 
357
    @staticmethod
 
358
    @deprecated_method(zero_eight)
 
359
    def create(branch, directory):
 
360
        """Create a workingtree for branch at directory.
 
361
 
 
362
        If existing_directory already exists it must have a .bzr directory.
 
363
        If it does not exist, it will be created.
 
364
 
 
365
        This returns a new WorkingTree object for the new checkout.
 
366
 
 
367
        TODO FIXME RBC 20060124 when we have checkout formats in place this
 
368
        should accept an optional revisionid to checkout [and reject this if
 
369
        checking out into the same dir as a pre-checkout-aware branch format.]
 
370
 
 
371
        XXX: When BzrDir is present, these should be created through that 
 
372
        interface instead.
 
373
        """
 
374
        warn('delete WorkingTree.create', stacklevel=3)
 
375
        transport = get_transport(directory)
 
376
        if branch.bzrdir.root_transport.base == transport.base:
 
377
            # same dir 
 
378
            return branch.bzrdir.create_workingtree()
 
379
        # different directory, 
 
380
        # create a branch reference
 
381
        # and now a working tree.
 
382
        raise NotImplementedError
 
383
 
 
384
    @staticmethod
 
385
    @deprecated_method(zero_eight)
 
386
    def create_standalone(directory):
 
387
        """Create a checkout and a branch and a repo at directory.
 
388
 
 
389
        Directory must exist and be empty.
 
390
 
 
391
        please use BzrDir.create_standalone_workingtree
 
392
        """
 
393
        return bzrdir.BzrDir.create_standalone_workingtree(directory)
 
394
 
 
395
    def relpath(self, abs):
 
396
        """Return the local path portion from a given absolute path."""
 
397
        return relpath(self.basedir, abs)
140
398
 
141
399
    def has_filename(self, filename):
142
400
        return bzrlib.osutils.lexists(self.abspath(filename))
147
405
    def get_file_byname(self, filename):
148
406
        return file(self.abspath(filename), 'rb')
149
407
 
 
408
    def get_root_id(self):
 
409
        """Return the id of this trees root"""
 
410
        inv = self.read_working_inventory()
 
411
        return inv.root.file_id
 
412
        
150
413
    def _get_store_filename(self, file_id):
151
 
        ## XXX: badly named; this isn't in the store at all
 
414
        ## XXX: badly named; this is not in the store at all
152
415
        return self.abspath(self.id2path(file_id))
153
416
 
 
417
    @needs_read_lock
 
418
    def clone(self, to_bzrdir, revision_id=None, basis=None):
 
419
        """Duplicate this working tree into to_bzr, including all state.
 
420
        
 
421
        Specifically modified files are kept as modified, but
 
422
        ignored and unknown files are discarded.
 
423
 
 
424
        If you want to make a new line of development, see bzrdir.sprout()
 
425
 
 
426
        revision
 
427
            If not None, the cloned tree will have its last revision set to 
 
428
            revision, and and difference between the source trees last revision
 
429
            and this one merged in.
 
430
 
 
431
        basis
 
432
            If not None, a closer copy of a tree which may have some files in
 
433
            common, and which file content should be preferentially copied from.
 
434
        """
 
435
        # assumes the target bzr dir format is compatible.
 
436
        result = self._format.initialize(to_bzrdir)
 
437
        self.copy_content_into(result, revision_id)
 
438
        return result
 
439
 
 
440
    @needs_read_lock
 
441
    def copy_content_into(self, tree, revision_id=None):
 
442
        """Copy the current content and user files of this tree into tree."""
 
443
        if revision_id is None:
 
444
            transform_tree(tree, self)
 
445
        else:
 
446
            # TODO now merge from tree.last_revision to revision
 
447
            transform_tree(tree, self)
 
448
            tree.set_last_revision(revision_id)
 
449
 
 
450
    @needs_write_lock
 
451
    def commit(self, *args, **kwargs):
 
452
        from bzrlib.commit import Commit
 
453
        # args for wt.commit start at message from the Commit.commit method,
 
454
        # but with branch a kwarg now, passing in args as is results in the
 
455
        #message being used for the branch
 
456
        args = (DEPRECATED_PARAMETER, ) + args
 
457
        Commit().commit(working_tree=self, *args, **kwargs)
 
458
        self._set_inventory(self.read_working_inventory())
154
459
 
155
460
    def id2abspath(self, file_id):
156
461
        return self.abspath(self.id2path(file_id))
157
462
 
158
 
                
159
463
    def has_id(self, file_id):
160
464
        # files that have been deleted are excluded
161
465
        inv = self._inventory
164
468
        path = inv.id2path(file_id)
165
469
        return bzrlib.osutils.lexists(self.abspath(path))
166
470
 
 
471
    def has_or_had_id(self, file_id):
 
472
        if file_id == self.inventory.root.file_id:
 
473
            return True
 
474
        return self.inventory.has_id(file_id)
167
475
 
168
476
    __contains__ = has_id
169
 
    
170
477
 
171
478
    def get_file_size(self, file_id):
172
479
        return os.path.getsize(self.id2abspath(file_id))
173
480
 
 
481
    @needs_read_lock
174
482
    def get_file_sha1(self, file_id):
175
483
        path = self._inventory.id2path(file_id)
176
484
        return self._hashcache.get_sha1(path)
177
485
 
178
 
 
179
486
    def is_executable(self, file_id):
180
487
        if os.name == "nt":
181
488
            return self._inventory[file_id].executable
184
491
            mode = os.lstat(self.abspath(path)).st_mode
185
492
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC&mode)
186
493
 
 
494
    @needs_write_lock
 
495
    def add(self, files, ids=None):
 
496
        """Make files versioned.
 
497
 
 
498
        Note that the command line normally calls smart_add instead,
 
499
        which can automatically recurse.
 
500
 
 
501
        This adds the files to the inventory, so that they will be
 
502
        recorded by the next commit.
 
503
 
 
504
        files
 
505
            List of paths to add, relative to the base of the tree.
 
506
 
 
507
        ids
 
508
            If set, use these instead of automatically generated ids.
 
509
            Must be the same length as the list of files, but may
 
510
            contain None for ids that are to be autogenerated.
 
511
 
 
512
        TODO: Perhaps have an option to add the ids even if the files do
 
513
              not (yet) exist.
 
514
 
 
515
        TODO: Perhaps callback with the ids and paths as they're added.
 
516
        """
 
517
        # TODO: Re-adding a file that is removed in the working copy
 
518
        # should probably put it back with the previous ID.
 
519
        if isinstance(files, basestring):
 
520
            assert(ids is None or isinstance(ids, basestring))
 
521
            files = [files]
 
522
            if ids is not None:
 
523
                ids = [ids]
 
524
 
 
525
        if ids is None:
 
526
            ids = [None] * len(files)
 
527
        else:
 
528
            assert(len(ids) == len(files))
 
529
 
 
530
        inv = self.read_working_inventory()
 
531
        for f,file_id in zip(files, ids):
 
532
            if self.is_control_filename(f):
 
533
                raise BzrError("cannot add control file %s" % quotefn(f))
 
534
 
 
535
            fp = splitpath(f)
 
536
 
 
537
            if len(fp) == 0:
 
538
                raise BzrError("cannot add top-level %r" % f)
 
539
 
 
540
            fullpath = normpath(self.abspath(f))
 
541
 
 
542
            try:
 
543
                kind = file_kind(fullpath)
 
544
            except OSError, e:
 
545
                if e.errno == errno.ENOENT:
 
546
                    raise NoSuchFile(fullpath)
 
547
                # maybe something better?
 
548
                raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
 
549
 
 
550
            if not InventoryEntry.versionable_kind(kind):
 
551
                raise BzrError('cannot add: not a versionable file ('
 
552
                               'i.e. regular file, symlink or directory): %s' % quotefn(f))
 
553
 
 
554
            if file_id is None:
 
555
                file_id = gen_file_id(f)
 
556
            inv.add_path(f, kind=kind, file_id=file_id)
 
557
 
 
558
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
559
        self._write_inventory(inv)
 
560
 
 
561
    @needs_write_lock
 
562
    def add_pending_merge(self, *revision_ids):
 
563
        # TODO: Perhaps should check at this point that the
 
564
        # history of the revision is actually present?
 
565
        p = self.pending_merges()
 
566
        updated = False
 
567
        for rev_id in revision_ids:
 
568
            if rev_id in p:
 
569
                continue
 
570
            p.append(rev_id)
 
571
            updated = True
 
572
        if updated:
 
573
            self.set_pending_merges(p)
 
574
 
 
575
    @needs_read_lock
 
576
    def pending_merges(self):
 
577
        """Return a list of pending merges.
 
578
 
 
579
        These are revisions that have been merged into the working
 
580
        directory but not yet committed.
 
581
        """
 
582
        try:
 
583
            merges_file = self._control_files.get_utf8('pending-merges')
 
584
        except OSError, e:
 
585
            if e.errno != errno.ENOENT:
 
586
                raise
 
587
            return []
 
588
        p = []
 
589
        for l in merges_file.readlines():
 
590
            p.append(l.rstrip('\n'))
 
591
        return p
 
592
 
 
593
    @needs_write_lock
 
594
    def set_pending_merges(self, rev_list):
 
595
        self._control_files.put_utf8('pending-merges', '\n'.join(rev_list))
 
596
 
187
597
    def get_symlink_target(self, file_id):
188
598
        return os.readlink(self.id2abspath(file_id))
189
599
 
195
605
        else:
196
606
            return '?'
197
607
 
198
 
 
199
608
    def list_files(self):
200
609
        """Recursively list all files as (path, class, kind, id).
201
610
 
215
624
                ## TODO: If we find a subdirectory with its own .bzr
216
625
                ## directory, then that is a separate tree and we
217
626
                ## should exclude it.
218
 
                if bzrlib.BZRDIR == f:
 
627
 
 
628
                # the bzrdir for this tree
 
629
                if self.bzrdir.transport.base.endswith(f + '/'):
219
630
                    continue
220
631
 
221
632
                # path within tree
265
676
                for ff in descend(fp, f_ie.file_id, fap):
266
677
                    yield ff
267
678
 
268
 
        for f in descend('', inv.root.file_id, self.basedir):
 
679
        for f in descend(u'', inv.root.file_id, self.basedir):
269
680
            yield f
270
 
            
271
 
 
272
 
 
 
681
 
 
682
    @needs_write_lock
 
683
    def move(self, from_paths, to_name):
 
684
        """Rename files.
 
685
 
 
686
        to_name must exist in the inventory.
 
687
 
 
688
        If to_name exists and is a directory, the files are moved into
 
689
        it, keeping their old names.  
 
690
 
 
691
        Note that to_name is only the last component of the new name;
 
692
        this doesn't change the directory.
 
693
 
 
694
        This returns a list of (from_path, to_path) pairs for each
 
695
        entry that is moved.
 
696
        """
 
697
        result = []
 
698
        ## TODO: Option to move IDs only
 
699
        assert not isinstance(from_paths, basestring)
 
700
        inv = self.inventory
 
701
        to_abs = self.abspath(to_name)
 
702
        if not isdir(to_abs):
 
703
            raise BzrError("destination %r is not a directory" % to_abs)
 
704
        if not self.has_filename(to_name):
 
705
            raise BzrError("destination %r not in working directory" % to_abs)
 
706
        to_dir_id = inv.path2id(to_name)
 
707
        if to_dir_id == None and to_name != '':
 
708
            raise BzrError("destination %r is not a versioned directory" % to_name)
 
709
        to_dir_ie = inv[to_dir_id]
 
710
        if to_dir_ie.kind not in ('directory', 'root_directory'):
 
711
            raise BzrError("destination %r is not a directory" % to_abs)
 
712
 
 
713
        to_idpath = inv.get_idpath(to_dir_id)
 
714
 
 
715
        for f in from_paths:
 
716
            if not self.has_filename(f):
 
717
                raise BzrError("%r does not exist in working tree" % f)
 
718
            f_id = inv.path2id(f)
 
719
            if f_id == None:
 
720
                raise BzrError("%r is not versioned" % f)
 
721
            name_tail = splitpath(f)[-1]
 
722
            dest_path = appendpath(to_name, name_tail)
 
723
            if self.has_filename(dest_path):
 
724
                raise BzrError("destination %r already exists" % dest_path)
 
725
            if f_id in to_idpath:
 
726
                raise BzrError("can't move %r to a subdirectory of itself" % f)
 
727
 
 
728
        # OK, so there's a race here, it's possible that someone will
 
729
        # create a file in this interval and then the rename might be
 
730
        # left half-done.  But we should have caught most problems.
 
731
        orig_inv = deepcopy(self.inventory)
 
732
        try:
 
733
            for f in from_paths:
 
734
                name_tail = splitpath(f)[-1]
 
735
                dest_path = appendpath(to_name, name_tail)
 
736
                result.append((f, dest_path))
 
737
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
738
                try:
 
739
                    rename(self.abspath(f), self.abspath(dest_path))
 
740
                except OSError, e:
 
741
                    raise BzrError("failed to rename %r to %r: %s" %
 
742
                                   (f, dest_path, e[1]),
 
743
                            ["rename rolled back"])
 
744
        except:
 
745
            # restore the inventory on error
 
746
            self._set_inventory(orig_inv)
 
747
            raise
 
748
        self._write_inventory(inv)
 
749
        return result
 
750
 
 
751
    @needs_write_lock
 
752
    def rename_one(self, from_rel, to_rel):
 
753
        """Rename one file.
 
754
 
 
755
        This can change the directory or the filename or both.
 
756
        """
 
757
        inv = self.inventory
 
758
        if not self.has_filename(from_rel):
 
759
            raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
760
        if self.has_filename(to_rel):
 
761
            raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
762
 
 
763
        file_id = inv.path2id(from_rel)
 
764
        if file_id == None:
 
765
            raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
766
 
 
767
        entry = inv[file_id]
 
768
        from_parent = entry.parent_id
 
769
        from_name = entry.name
 
770
        
 
771
        if inv.path2id(to_rel):
 
772
            raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
773
 
 
774
        to_dir, to_tail = os.path.split(to_rel)
 
775
        to_dir_id = inv.path2id(to_dir)
 
776
        if to_dir_id == None and to_dir != '':
 
777
            raise BzrError("can't determine destination directory id for %r" % to_dir)
 
778
 
 
779
        mutter("rename_one:")
 
780
        mutter("  file_id    {%s}" % file_id)
 
781
        mutter("  from_rel   %r" % from_rel)
 
782
        mutter("  to_rel     %r" % to_rel)
 
783
        mutter("  to_dir     %r" % to_dir)
 
784
        mutter("  to_dir_id  {%s}" % to_dir_id)
 
785
 
 
786
        inv.rename(file_id, to_dir_id, to_tail)
 
787
 
 
788
        from_abs = self.abspath(from_rel)
 
789
        to_abs = self.abspath(to_rel)
 
790
        try:
 
791
            rename(from_abs, to_abs)
 
792
        except OSError, e:
 
793
            inv.rename(file_id, from_parent, from_name)
 
794
            raise BzrError("failed to rename %r to %r: %s"
 
795
                    % (from_abs, to_abs, e[1]),
 
796
                    ["rename rolled back"])
 
797
        self._write_inventory(inv)
 
798
 
 
799
    @needs_read_lock
273
800
    def unknowns(self):
 
801
        """Return all unknown files.
 
802
 
 
803
        These are files in the working directory that are not versioned or
 
804
        control files or ignored.
 
805
        
 
806
        >>> from bzrlib.bzrdir import ScratchDir
 
807
        >>> d = ScratchDir(files=['foo', 'foo~'])
 
808
        >>> b = d.open_branch()
 
809
        >>> tree = d.open_workingtree()
 
810
        >>> map(str, tree.unknowns())
 
811
        ['foo']
 
812
        >>> tree.add('foo')
 
813
        >>> list(b.unknowns())
 
814
        []
 
815
        >>> tree.remove('foo')
 
816
        >>> list(b.unknowns())
 
817
        [u'foo']
 
818
        """
274
819
        for subp in self.extras():
275
820
            if not self.is_ignored(subp):
276
821
                yield subp
285
830
                conflicted.add(stem)
286
831
                yield stem
287
832
 
 
833
    @needs_write_lock
 
834
    def pull(self, source, overwrite=False, stop_revision=None):
 
835
        source.lock_read()
 
836
        try:
 
837
            old_revision_history = self.branch.revision_history()
 
838
            count = self.branch.pull(source, overwrite, stop_revision)
 
839
            new_revision_history = self.branch.revision_history()
 
840
            if new_revision_history != old_revision_history:
 
841
                if len(old_revision_history):
 
842
                    other_revision = old_revision_history[-1]
 
843
                else:
 
844
                    other_revision = None
 
845
                repository = self.branch.repository
 
846
                merge_inner(self.branch,
 
847
                            self.basis_tree(), 
 
848
                            repository.revision_tree(other_revision),
 
849
                            this_tree=self)
 
850
                self.set_last_revision(self.branch.last_revision())
 
851
            return count
 
852
        finally:
 
853
            source.unlock()
 
854
 
288
855
    def extras(self):
289
856
        """Yield all unknown files in this WorkingTree.
290
857
 
296
863
        """
297
864
        ## TODO: Work from given directory downwards
298
865
        for path, dir_entry in self.inventory.directories():
299
 
            mutter("search for unknowns in %r" % path)
 
866
            mutter("search for unknowns in %r", path)
300
867
            dirabs = self.abspath(path)
301
868
            if not isdir(dirabs):
302
869
                # e.g. directory deleted
376
943
        else:
377
944
            return None
378
945
 
 
946
    def kind(self, file_id):
 
947
        return file_kind(self.id2abspath(file_id))
 
948
 
 
949
    @needs_read_lock
 
950
    def last_revision(self):
 
951
        """Return the last revision id of this working tree.
 
952
 
 
953
        In early branch formats this was == the branch last_revision,
 
954
        but that cannot be relied upon - for working tree operations,
 
955
        always use tree.last_revision().
 
956
        """
 
957
        return self.branch.last_revision()
 
958
 
 
959
    def lock_read(self):
 
960
        """See Branch.lock_read, and WorkingTree.unlock."""
 
961
        self.branch.lock_read()
 
962
        try:
 
963
            return self._control_files.lock_read()
 
964
        except:
 
965
            self.branch.unlock()
 
966
            raise
 
967
 
 
968
    def lock_write(self):
 
969
        """See Branch.lock_write, and WorkingTree.unlock."""
 
970
        self.branch.lock_write()
 
971
        try:
 
972
            return self._control_files.lock_write()
 
973
        except:
 
974
            self.branch.unlock()
 
975
            raise
 
976
 
 
977
    def _basis_inventory_name(self, revision_id):
 
978
        return 'basis-inventory.%s' % revision_id
 
979
 
 
980
    @needs_write_lock
 
981
    def set_last_revision(self, new_revision, old_revision=None):
 
982
        """Change the last revision in the working tree."""
 
983
        self._remove_old_basis(old_revision)
 
984
        if self._change_last_revision(new_revision):
 
985
            self._cache_basis_inventory(new_revision)
 
986
 
 
987
    def _change_last_revision(self, new_revision):
 
988
        """Template method part of set_last_revision to perform the change."""
 
989
        if new_revision is None:
 
990
            self.branch.set_revision_history([])
 
991
            return False
 
992
        # current format is locked in with the branch
 
993
        revision_history = self.branch.revision_history()
 
994
        try:
 
995
            position = revision_history.index(new_revision)
 
996
        except ValueError:
 
997
            raise errors.NoSuchRevision(self.branch, new_revision)
 
998
        self.branch.set_revision_history(revision_history[:position + 1])
 
999
        return True
 
1000
 
 
1001
    def _cache_basis_inventory(self, new_revision):
 
1002
        """Cache new_revision as the basis inventory."""
 
1003
        try:
 
1004
            xml = self.branch.repository.get_inventory_xml(new_revision)
 
1005
            path = self._basis_inventory_name(new_revision)
 
1006
            self._control_files.put_utf8(path, xml)
 
1007
        except WeaveRevisionNotPresent:
 
1008
            pass
 
1009
 
 
1010
    def _remove_old_basis(self, old_revision):
 
1011
        """Remove the old basis inventory 'old_revision'."""
 
1012
        if old_revision is not None:
 
1013
            try:
 
1014
                path = self._basis_inventory_name(old_revision)
 
1015
                path = self._control_files._escape(path)
 
1016
                self._control_files._transport.delete(path)
 
1017
            except NoSuchFile:
 
1018
                pass
 
1019
 
 
1020
    def read_basis_inventory(self, revision_id):
 
1021
        """Read the cached basis inventory."""
 
1022
        path = self._basis_inventory_name(revision_id)
 
1023
        return self._control_files.get_utf8(path).read()
 
1024
        
 
1025
    @needs_read_lock
 
1026
    def read_working_inventory(self):
 
1027
        """Read the working inventory."""
 
1028
        # ElementTree does its own conversion from UTF-8, so open in
 
1029
        # binary.
 
1030
        result = bzrlib.xml5.serializer_v5.read_inventory(
 
1031
            self._control_files.get('inventory'))
 
1032
        self._set_inventory(result)
 
1033
        return result
 
1034
 
 
1035
    @needs_write_lock
 
1036
    def remove(self, files, verbose=False):
 
1037
        """Remove nominated files from the working inventory..
 
1038
 
 
1039
        This does not remove their text.  This does not run on XXX on what? RBC
 
1040
 
 
1041
        TODO: Refuse to remove modified files unless --force is given?
 
1042
 
 
1043
        TODO: Do something useful with directories.
 
1044
 
 
1045
        TODO: Should this remove the text or not?  Tough call; not
 
1046
        removing may be useful and the user can just use use rm, and
 
1047
        is the opposite of add.  Removing it is consistent with most
 
1048
        other tools.  Maybe an option.
 
1049
        """
 
1050
        ## TODO: Normalize names
 
1051
        ## TODO: Remove nested loops; better scalability
 
1052
        if isinstance(files, basestring):
 
1053
            files = [files]
 
1054
 
 
1055
        inv = self.inventory
 
1056
 
 
1057
        # do this before any modifications
 
1058
        for f in files:
 
1059
            fid = inv.path2id(f)
 
1060
            if not fid:
 
1061
                # TODO: Perhaps make this just a warning, and continue?
 
1062
                # This tends to happen when 
 
1063
                raise NotVersionedError(path=f)
 
1064
            mutter("remove inventory entry %s {%s}", quotefn(f), fid)
 
1065
            if verbose:
 
1066
                # having remove it, it must be either ignored or unknown
 
1067
                if self.is_ignored(f):
 
1068
                    new_status = 'I'
 
1069
                else:
 
1070
                    new_status = '?'
 
1071
                show_status(new_status, inv[fid].kind, quotefn(f))
 
1072
            del inv[fid]
 
1073
 
 
1074
        self._write_inventory(inv)
 
1075
 
 
1076
    @needs_write_lock
 
1077
    def revert(self, filenames, old_tree=None, backups=True):
 
1078
        from bzrlib.merge import merge_inner
 
1079
        if old_tree is None:
 
1080
            old_tree = self.basis_tree()
 
1081
        merge_inner(self.branch, old_tree,
 
1082
                    self, ignore_zero=True,
 
1083
                    backup_files=backups, 
 
1084
                    interesting_files=filenames,
 
1085
                    this_tree=self)
 
1086
        if not len(filenames):
 
1087
            self.set_pending_merges([])
 
1088
 
 
1089
    @needs_write_lock
 
1090
    def set_inventory(self, new_inventory_list):
 
1091
        from bzrlib.inventory import (Inventory,
 
1092
                                      InventoryDirectory,
 
1093
                                      InventoryEntry,
 
1094
                                      InventoryFile,
 
1095
                                      InventoryLink)
 
1096
        inv = Inventory(self.get_root_id())
 
1097
        for path, file_id, parent, kind in new_inventory_list:
 
1098
            name = os.path.basename(path)
 
1099
            if name == "":
 
1100
                continue
 
1101
            # fixme, there should be a factory function inv,add_?? 
 
1102
            if kind == 'directory':
 
1103
                inv.add(InventoryDirectory(file_id, name, parent))
 
1104
            elif kind == 'file':
 
1105
                inv.add(InventoryFile(file_id, name, parent))
 
1106
            elif kind == 'symlink':
 
1107
                inv.add(InventoryLink(file_id, name, parent))
 
1108
            else:
 
1109
                raise BzrError("unknown kind %r" % kind)
 
1110
        self._write_inventory(inv)
 
1111
 
 
1112
    @needs_write_lock
 
1113
    def set_root_id(self, file_id):
 
1114
        """Set the root id for this tree."""
 
1115
        inv = self.read_working_inventory()
 
1116
        orig_root_id = inv.root.file_id
 
1117
        del inv._byid[inv.root.file_id]
 
1118
        inv.root.file_id = file_id
 
1119
        inv._byid[inv.root.file_id] = inv.root
 
1120
        for fid in inv:
 
1121
            entry = inv[fid]
 
1122
            if entry.parent_id == orig_root_id:
 
1123
                entry.parent_id = inv.root.file_id
 
1124
        self._write_inventory(inv)
 
1125
 
 
1126
    def unlock(self):
 
1127
        """See Branch.unlock.
 
1128
        
 
1129
        WorkingTree locking just uses the Branch locking facilities.
 
1130
        This is current because all working trees have an embedded branch
 
1131
        within them. IF in the future, we were to make branch data shareable
 
1132
        between multiple working trees, i.e. via shared storage, then we 
 
1133
        would probably want to lock both the local tree, and the branch.
 
1134
        """
 
1135
        # FIXME: We want to write out the hashcache only when the last lock on
 
1136
        # this working copy is released.  Peeking at the lock count is a bit
 
1137
        # of a nasty hack; probably it's better to have a transaction object,
 
1138
        # which can do some finalization when it's either successfully or
 
1139
        # unsuccessfully completed.  (Denys's original patch did that.)
 
1140
        # RBC 20060206 hookinhg into transaction will couple lock and transaction
 
1141
        # wrongly. Hookinh into unllock on the control files object is fine though.
 
1142
        
 
1143
        # TODO: split this per format so there is no ugly if block
 
1144
        if self._hashcache.needs_write and (
 
1145
            # dedicated lock files
 
1146
            self._control_files._lock_count==1 or 
 
1147
            # shared lock files
 
1148
            (self._control_files is self.branch.control_files and 
 
1149
             self._control_files._lock_count==3)):
 
1150
            self._hashcache.write()
 
1151
        # reverse order of locking.
 
1152
        result = self._control_files.unlock()
 
1153
        try:
 
1154
            self.branch.unlock()
 
1155
        finally:
 
1156
            return result
 
1157
 
 
1158
    @needs_write_lock
 
1159
    def update(self):
 
1160
        self.branch.lock_read()
 
1161
        try:
 
1162
            if self.last_revision() == self.branch.last_revision():
 
1163
                return
 
1164
            basis = self.basis_tree()
 
1165
            to_tree = self.branch.basis_tree()
 
1166
            result = merge_inner(self.branch,
 
1167
                                 to_tree,
 
1168
                                 basis,
 
1169
                                 this_tree=self)
 
1170
            self.set_last_revision(self.branch.last_revision())
 
1171
            return result
 
1172
        finally:
 
1173
            self.branch.unlock()
 
1174
 
 
1175
    @needs_write_lock
 
1176
    def _write_inventory(self, inv):
 
1177
        """Write inventory as the current inventory."""
 
1178
        sio = StringIO()
 
1179
        bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
 
1180
        sio.seek(0)
 
1181
        self._control_files.put('inventory', sio)
 
1182
        self._set_inventory(inv)
 
1183
        mutter('wrote working inventory')
 
1184
 
 
1185
 
 
1186
class WorkingTree3(WorkingTree):
 
1187
    """This is the Format 3 working tree.
 
1188
 
 
1189
    This differs from the base WorkingTree by:
 
1190
     - having its own file lock
 
1191
     - having its own last-revision property.
 
1192
    """
 
1193
 
 
1194
    @needs_read_lock
 
1195
    def last_revision(self):
 
1196
        """See WorkingTree.last_revision."""
 
1197
        try:
 
1198
            return self._control_files.get_utf8('last-revision').read()
 
1199
        except NoSuchFile:
 
1200
            return None
 
1201
 
 
1202
    def _change_last_revision(self, revision_id):
 
1203
        """See WorkingTree._change_last_revision."""
 
1204
        if revision_id is None or revision_id == NULL_REVISION:
 
1205
            try:
 
1206
                self._control_files._transport.delete('last-revision')
 
1207
            except errors.NoSuchFile:
 
1208
                pass
 
1209
            return False
 
1210
        else:
 
1211
            try:
 
1212
                self.branch.revision_history().index(revision_id)
 
1213
            except ValueError:
 
1214
                raise errors.NoSuchRevision(self.branch, revision_id)
 
1215
            self._control_files.put_utf8('last-revision', revision_id)
 
1216
            return True
 
1217
 
 
1218
 
379
1219
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
380
1220
def get_conflicted_stem(path):
381
1221
    for suffix in CONFLICT_SUFFIXES:
382
1222
        if path.endswith(suffix):
383
1223
            return path[:-len(suffix)]
 
1224
 
 
1225
@deprecated_function(zero_eight)
 
1226
def is_control_file(filename):
 
1227
    """See WorkingTree.is_control_filename(filename)."""
 
1228
    ## FIXME: better check
 
1229
    filename = normpath(filename)
 
1230
    while filename != '':
 
1231
        head, tail = os.path.split(filename)
 
1232
        ## mutter('check %r for control file' % ((head, tail),))
 
1233
        if tail == '.bzr':
 
1234
            return True
 
1235
        if filename == head:
 
1236
            break
 
1237
        filename = head
 
1238
    return False
 
1239
 
 
1240
 
 
1241
class WorkingTreeFormat(object):
 
1242
    """An encapsulation of the initialization and open routines for a format.
 
1243
 
 
1244
    Formats provide three things:
 
1245
     * An initialization routine,
 
1246
     * a format string,
 
1247
     * an open routine.
 
1248
 
 
1249
    Formats are placed in an dict by their format string for reference 
 
1250
    during workingtree opening. Its not required that these be instances, they
 
1251
    can be classes themselves with class methods - it simply depends on 
 
1252
    whether state is needed for a given format or not.
 
1253
 
 
1254
    Once a format is deprecated, just deprecate the initialize and open
 
1255
    methods on the format class. Do not deprecate the object, as the 
 
1256
    object will be created every time regardless.
 
1257
    """
 
1258
 
 
1259
    _default_format = None
 
1260
    """The default format used for new trees."""
 
1261
 
 
1262
    _formats = {}
 
1263
    """The known formats."""
 
1264
 
 
1265
    @classmethod
 
1266
    def find_format(klass, a_bzrdir):
 
1267
        """Return the format for the working tree object in a_bzrdir."""
 
1268
        try:
 
1269
            transport = a_bzrdir.get_workingtree_transport(None)
 
1270
            format_string = transport.get("format").read()
 
1271
            return klass._formats[format_string]
 
1272
        except NoSuchFile:
 
1273
            raise errors.NoWorkingTree(base=transport.base)
 
1274
        except KeyError:
 
1275
            raise errors.UnknownFormatError(format_string)
 
1276
 
 
1277
    @classmethod
 
1278
    def get_default_format(klass):
 
1279
        """Return the current default format."""
 
1280
        return klass._default_format
 
1281
 
 
1282
    def get_format_string(self):
 
1283
        """Return the ASCII format string that identifies this format."""
 
1284
        raise NotImplementedError(self.get_format_string)
 
1285
 
 
1286
    def is_supported(self):
 
1287
        """Is this format supported?
 
1288
 
 
1289
        Supported formats can be initialized and opened.
 
1290
        Unsupported formats may not support initialization or committing or 
 
1291
        some other features depending on the reason for not being supported.
 
1292
        """
 
1293
        return True
 
1294
 
 
1295
    @classmethod
 
1296
    def register_format(klass, format):
 
1297
        klass._formats[format.get_format_string()] = format
 
1298
 
 
1299
    @classmethod
 
1300
    def set_default_format(klass, format):
 
1301
        klass._default_format = format
 
1302
 
 
1303
    @classmethod
 
1304
    def unregister_format(klass, format):
 
1305
        assert klass._formats[format.get_format_string()] is format
 
1306
        del klass._formats[format.get_format_string()]
 
1307
 
 
1308
 
 
1309
 
 
1310
class WorkingTreeFormat2(WorkingTreeFormat):
 
1311
    """The second working tree format. 
 
1312
 
 
1313
    This format modified the hash cache from the format 1 hash cache.
 
1314
    """
 
1315
 
 
1316
    def initialize(self, a_bzrdir, revision_id=None):
 
1317
        """See WorkingTreeFormat.initialize()."""
 
1318
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1319
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1320
        branch = a_bzrdir.open_branch()
 
1321
        if revision_id is not None:
 
1322
            branch.lock_write()
 
1323
            try:
 
1324
                revision_history = branch.revision_history()
 
1325
                try:
 
1326
                    position = revision_history.index(revision_id)
 
1327
                except ValueError:
 
1328
                    raise errors.NoSuchRevision(branch, revision_id)
 
1329
                branch.set_revision_history(revision_history[:position + 1])
 
1330
            finally:
 
1331
                branch.unlock()
 
1332
        revision = branch.last_revision()
 
1333
        basis_tree = branch.repository.revision_tree(revision)
 
1334
        inv = basis_tree.inventory
 
1335
        wt = WorkingTree(a_bzrdir.root_transport.base,
 
1336
                         branch,
 
1337
                         inv,
 
1338
                         _internal=True,
 
1339
                         _format=self,
 
1340
                         _bzrdir=a_bzrdir)
 
1341
        wt._write_inventory(inv)
 
1342
        wt.set_root_id(inv.root.file_id)
 
1343
        wt.set_last_revision(revision)
 
1344
        wt.set_pending_merges([])
 
1345
        wt.revert([])
 
1346
        return wt
 
1347
 
 
1348
    def __init__(self):
 
1349
        super(WorkingTreeFormat2, self).__init__()
 
1350
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
 
1351
 
 
1352
    def open(self, a_bzrdir, _found=False):
 
1353
        """Return the WorkingTree object for a_bzrdir
 
1354
 
 
1355
        _found is a private parameter, do not use it. It is used to indicate
 
1356
               if format probing has already been done.
 
1357
        """
 
1358
        if not _found:
 
1359
            # we are being called directly and must probe.
 
1360
            raise NotImplementedError
 
1361
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1362
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1363
        return WorkingTree(a_bzrdir.root_transport.base,
 
1364
                           _internal=True,
 
1365
                           _format=self,
 
1366
                           _bzrdir=a_bzrdir)
 
1367
 
 
1368
 
 
1369
class WorkingTreeFormat3(WorkingTreeFormat):
 
1370
    """The second working tree format updated to record a format marker.
 
1371
 
 
1372
    This format modified the hash cache from the format 1 hash cache.
 
1373
    """
 
1374
 
 
1375
    def get_format_string(self):
 
1376
        """See WorkingTreeFormat.get_format_string()."""
 
1377
        return "Bazaar-NG Working Tree format 3"
 
1378
 
 
1379
    def initialize(self, a_bzrdir, revision_id=None):
 
1380
        """See WorkingTreeFormat.initialize().
 
1381
        
 
1382
        revision_id allows creating a working tree at a differnet
 
1383
        revision than the branch is at.
 
1384
        """
 
1385
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1386
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1387
        transport = a_bzrdir.get_workingtree_transport(self)
 
1388
        control_files = LockableFiles(transport, 'lock')
 
1389
        control_files.put_utf8('format', self.get_format_string())
 
1390
        branch = a_bzrdir.open_branch()
 
1391
        if revision_id is None:
 
1392
            revision_id = branch.last_revision()
 
1393
        new_basis_tree = branch.repository.revision_tree(revision_id)
 
1394
        inv = new_basis_tree.inventory
 
1395
        wt = WorkingTree3(a_bzrdir.root_transport.base,
 
1396
                         branch,
 
1397
                         inv,
 
1398
                         _internal=True,
 
1399
                         _format=self,
 
1400
                         _bzrdir=a_bzrdir)
 
1401
        wt._write_inventory(inv)
 
1402
        wt.set_root_id(inv.root.file_id)
 
1403
        wt.set_last_revision(revision_id)
 
1404
        wt.set_pending_merges([])
 
1405
        wt.revert([])
 
1406
        return wt
 
1407
 
 
1408
    def __init__(self):
 
1409
        super(WorkingTreeFormat3, self).__init__()
 
1410
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1411
 
 
1412
    def open(self, a_bzrdir, _found=False):
 
1413
        """Return the WorkingTree object for a_bzrdir
 
1414
 
 
1415
        _found is a private parameter, do not use it. It is used to indicate
 
1416
               if format probing has already been done.
 
1417
        """
 
1418
        if not _found:
 
1419
            # we are being called directly and must probe.
 
1420
            raise NotImplementedError
 
1421
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1422
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1423
        return WorkingTree3(a_bzrdir.root_transport.base,
 
1424
                           _internal=True,
 
1425
                           _format=self,
 
1426
                           _bzrdir=a_bzrdir)
 
1427
 
 
1428
    def __str__(self):
 
1429
        return self.get_format_string()
 
1430
 
 
1431
 
 
1432
# formats which have no format string are not discoverable
 
1433
# and not independently creatable, so are not registered.
 
1434
__default_format = WorkingTreeFormat3()
 
1435
WorkingTreeFormat.register_format(__default_format)
 
1436
WorkingTreeFormat.set_default_format(__default_format)
 
1437
_legacy_formats = [WorkingTreeFormat2(),
 
1438
                   ]
 
1439
 
 
1440
 
 
1441
class WorkingTreeTestProviderAdapter(object):
 
1442
    """A tool to generate a suite testing multiple workingtree formats at once.
 
1443
 
 
1444
    This is done by copying the test once for each transport and injecting
 
1445
    the transport_server, transport_readonly_server, and workingtree_format
 
1446
    classes into each copy. Each copy is also given a new id() to make it
 
1447
    easy to identify.
 
1448
    """
 
1449
 
 
1450
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1451
        self._transport_server = transport_server
 
1452
        self._transport_readonly_server = transport_readonly_server
 
1453
        self._formats = formats
 
1454
    
 
1455
    def adapt(self, test):
 
1456
        from bzrlib.tests import TestSuite
 
1457
        result = TestSuite()
 
1458
        for workingtree_format, bzrdir_format in self._formats:
 
1459
            new_test = deepcopy(test)
 
1460
            new_test.transport_server = self._transport_server
 
1461
            new_test.transport_readonly_server = self._transport_readonly_server
 
1462
            new_test.bzrdir_format = bzrdir_format
 
1463
            new_test.workingtree_format = workingtree_format
 
1464
            def make_new_test_id():
 
1465
                new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
 
1466
                return lambda: new_id
 
1467
            new_test.id = make_new_test_id()
 
1468
            result.addTest(new_test)
 
1469
        return result