/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

Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
1
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
 
 
 
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
39
39
# At the moment they may alias the inventory and have old copies of it in
40
40
# memory.  (Now done? -- mbp 20060309)
41
41
 
 
42
from binascii import hexlify
 
43
import collections
42
44
from copy import deepcopy
43
45
from cStringIO import StringIO
44
46
import errno
45
47
import fnmatch
46
48
import os
 
49
import re
47
50
import stat
48
 
 
 
51
from time import time
 
52
import warnings
49
53
 
 
54
import bzrlib
 
55
from bzrlib import bzrdir, errors, ignores, osutils, urlutils
50
56
from bzrlib.atomicfile import AtomicFile
51
 
from bzrlib.branch import (Branch,
52
 
                           quotefn)
 
57
import bzrlib.branch
53
58
from bzrlib.conflicts import Conflict, ConflictList, CONFLICT_SUFFIXES
54
 
import bzrlib.bzrdir as bzrdir
55
59
from bzrlib.decorators import needs_read_lock, needs_write_lock
56
 
import bzrlib.errors as errors
57
60
from bzrlib.errors import (BzrCheckError,
58
61
                           BzrError,
59
62
                           ConflictFormatError,
60
 
                           DivergedBranches,
61
63
                           WeaveRevisionNotPresent,
62
64
                           NotBranchError,
63
65
                           NoSuchFile,
71
73
from bzrlib.merge import merge_inner, transform_tree
72
74
from bzrlib.osutils import (
73
75
                            abspath,
74
 
                            appendpath,
75
76
                            compact_date,
76
77
                            file_kind,
77
78
                            isdir,
80
81
                            pumpfile,
81
82
                            safe_unicode,
82
83
                            splitpath,
83
 
                            rand_bytes,
 
84
                            rand_chars,
84
85
                            normpath,
85
86
                            realpath,
86
87
                            relpath,
90
91
from bzrlib.progress import DummyProgress, ProgressPhase
91
92
from bzrlib.revision import NULL_REVISION
92
93
from bzrlib.rio import RioReader, rio_file, Stanza
93
 
from bzrlib.symbol_versioning import *
94
 
from bzrlib.textui import show_status
95
 
import bzrlib.tree
 
94
from bzrlib.symbol_versioning import (deprecated_passed,
 
95
        deprecated_method,
 
96
        deprecated_function,
 
97
        DEPRECATED_PARAMETER,
 
98
        zero_eight,
 
99
        )
 
100
from bzrlib.trace import mutter, note
96
101
from bzrlib.transform import build_tree
97
 
from bzrlib.trace import mutter, note
98
102
from bzrlib.transport import get_transport
99
103
from bzrlib.transport.local import LocalTransport
 
104
from bzrlib.textui import show_status
 
105
import bzrlib.tree
100
106
import bzrlib.ui
101
107
import bzrlib.xml5
102
108
 
103
109
 
 
110
# the regex removes any weird characters; we don't escape them 
 
111
# but rather just pull them out
 
112
_gen_file_id_re = re.compile(r'[^\w.]')
 
113
_gen_id_suffix = None
 
114
_gen_id_serial = 0
 
115
 
 
116
 
 
117
def _next_id_suffix():
 
118
    """Create a new file id suffix that is reasonably unique.
 
119
    
 
120
    On the first call we combine the current time with 64 bits of randomness
 
121
    to give a highly probably globally unique number. Then each call in the same
 
122
    process adds 1 to a serial number we append to that unique value.
 
123
    """
 
124
    # XXX TODO: change bzrlib.add.smart_add to call workingtree.add() rather 
 
125
    # than having to move the id randomness out of the inner loop like this.
 
126
    # XXX TODO: for the global randomness this uses we should add the thread-id
 
127
    # before the serial #.
 
128
    global _gen_id_suffix, _gen_id_serial
 
129
    if _gen_id_suffix is None:
 
130
        _gen_id_suffix = "-%s-%s-" % (compact_date(time()), rand_chars(16))
 
131
    _gen_id_serial += 1
 
132
    return _gen_id_suffix + str(_gen_id_serial)
 
133
 
 
134
 
104
135
def gen_file_id(name):
105
 
    """Return new file id.
106
 
 
107
 
    This should probably generate proper UUIDs, but for the moment we
108
 
    cope with just randomness because running uuidgen every time is
109
 
    slow."""
110
 
    import re
111
 
    from binascii import hexlify
112
 
    from time import time
113
 
 
114
 
    # get last component
115
 
    idx = name.rfind('/')
116
 
    if idx != -1:
117
 
        name = name[idx+1 : ]
118
 
    idx = name.rfind('\\')
119
 
    if idx != -1:
120
 
        name = name[idx+1 : ]
121
 
 
122
 
    # make it not a hidden file
123
 
    name = name.lstrip('.')
124
 
 
125
 
    # remove any wierd characters; we don't escape them but rather
126
 
    # just pull them out
127
 
    name = re.sub(r'[^\w.]', '', name)
128
 
 
129
 
    s = hexlify(rand_bytes(8))
130
 
    return '-'.join((name, compact_date(time()), s))
 
136
    """Return new file id for the basename 'name'.
 
137
 
 
138
    The uniqueness is supplied from _next_id_suffix.
 
139
    """
 
140
    # The real randomness is in the _next_id_suffix, the
 
141
    # rest of the identifier is just to be nice.
 
142
    # So we:
 
143
    # 1) Remove non-ascii word characters to keep the ids portable
 
144
    # 2) squash to lowercase, so the file id doesn't have to
 
145
    #    be escaped (case insensitive filesystems would bork for ids
 
146
    #    that only differred in case without escaping).
 
147
    # 3) truncate the filename to 20 chars. Long filenames also bork on some
 
148
    #    filesystems
 
149
    # 4) Removing starting '.' characters to prevent the file ids from
 
150
    #    being considered hidden.
 
151
    ascii_word_only = _gen_file_id_re.sub('', name.lower())
 
152
    short_no_dots = ascii_word_only.lstrip('.')[:20]
 
153
    return short_no_dots + _next_id_suffix()
131
154
 
132
155
 
133
156
def gen_root_id():
136
159
 
137
160
 
138
161
class TreeEntry(object):
139
 
    """An entry that implements the minium interface used by commands.
 
162
    """An entry that implements the minimum interface used by commands.
140
163
 
141
164
    This needs further inspection, it may be better to have 
142
165
    InventoryEntries without ids - though that seems wrong. For now,
218
241
        self.bzrdir = _bzrdir
219
242
        if not _internal:
220
243
            # not created via open etc.
221
 
            warn("WorkingTree() is deprecated as of bzr version 0.8. "
 
244
            warnings.warn("WorkingTree() is deprecated as of bzr version 0.8. "
222
245
                 "Please use bzrdir.open_workingtree or WorkingTree.open().",
223
246
                 DeprecationWarning,
224
247
                 stacklevel=2)
225
248
            wt = WorkingTree.open(basedir)
226
 
            self.branch = wt.branch
 
249
            self._branch = wt.branch
227
250
            self.basedir = wt.basedir
228
251
            self._control_files = wt._control_files
229
252
            self._hashcache = wt._hashcache
238
261
        mutter("opening working tree %r", basedir)
239
262
        if deprecated_passed(branch):
240
263
            if not _internal:
241
 
                warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
 
264
                warnings.warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
242
265
                     " Please use bzrdir.open_workingtree() or"
243
266
                     " WorkingTree.open().",
244
267
                     DeprecationWarning,
245
268
                     stacklevel=2
246
269
                     )
247
 
            self.branch = branch
 
270
            self._branch = branch
248
271
        else:
249
 
            self.branch = self.bzrdir.open_branch()
250
 
        assert isinstance(self.branch, Branch), \
251
 
            "branch %r is not a Branch" % self.branch
 
272
            self._branch = self.bzrdir.open_branch()
252
273
        self.basedir = realpath(basedir)
253
274
        # if branch is at our basedir and is a format 6 or less
254
275
        if isinstance(self._format, WorkingTreeFormat2):
255
276
            # share control object
256
277
            self._control_files = self.branch.control_files
257
278
        else:
258
 
            # only ready for format 3
259
 
            assert isinstance(self._format, WorkingTreeFormat3)
 
279
            # assume all other formats have their own control files.
260
280
            assert isinstance(_control_files, LockableFiles), \
261
281
                    "_control_files must be a LockableFiles, not %r" \
262
282
                    % _control_files
267
287
        # if needed, or, when the cache sees a change, append it to the hash
268
288
        # cache file, and have the parser take the most recent entry for a
269
289
        # given path only.
270
 
        cache_filename = self.bzrdir.get_workingtree_transport(None).abspath('stat-cache')
 
290
        cache_filename = self.bzrdir.get_workingtree_transport(None).local_abspath('stat-cache')
271
291
        hc = self._hashcache = HashCache(basedir, cache_filename, self._control_files._file_mode)
272
292
        hc.read()
273
293
        # is this scan needed ? it makes things kinda slow.
274
 
        hc.scan()
 
294
        #hc.scan()
275
295
 
276
296
        if hc.needs_write:
277
297
            mutter("write hc")
282
302
        else:
283
303
            self._set_inventory(_inventory)
284
304
 
 
305
    branch = property(
 
306
        fget=lambda self: self._branch,
 
307
        doc="""The branch this WorkingTree is connected to.
 
308
 
 
309
            This cannot be set - it is reflective of the actual disk structure
 
310
            the working tree has been constructed from.
 
311
            """)
 
312
 
 
313
    def break_lock(self):
 
314
        """Break a lock if one is present from another instance.
 
315
 
 
316
        Uses the ui factory to ask for confirmation if the lock may be from
 
317
        an active process.
 
318
 
 
319
        This will probe the repository for its lock as well.
 
320
        """
 
321
        self._control_files.break_lock()
 
322
        self.branch.break_lock()
 
323
 
285
324
    def _set_inventory(self, inv):
 
325
        assert inv.root is not None
286
326
        self._inventory = inv
287
327
        self.path2id = self._inventory.path2id
288
328
 
289
329
    def is_control_filename(self, filename):
290
330
        """True if filename is the name of a control file in this tree.
291
331
        
 
332
        :param filename: A filename within the tree. This is a relative path
 
333
        from the root of this tree.
 
334
 
292
335
        This is true IF and ONLY IF the filename is part of the meta data
293
336
        that bzr controls in this tree. I.E. a random .bzr directory placed
294
337
        on disk will not be a control file for this tree.
295
338
        """
296
 
        try:
297
 
            self.bzrdir.transport.relpath(self.abspath(filename))
298
 
            return True
299
 
        except errors.PathNotChild:
300
 
            return False
 
339
        return self.bzrdir.is_control_filename(filename)
301
340
 
302
341
    @staticmethod
303
342
    def open(path=None, _unsupported=False):
319
358
        run into /.  If there isn't one, raises NotBranchError.
320
359
        TODO: give this a new exception.
321
360
        If there is one, it is returned, along with the unused portion of path.
 
361
 
 
362
        :return: The WorkingTree that contains 'path', and the rest of path
322
363
        """
323
364
        if path is None:
324
 
            path = os.getcwdu()
 
365
            path = osutils.getcwd()
325
366
        control, relpath = bzrdir.BzrDir.open_containing(path)
 
367
 
326
368
        return control.open_workingtree(), relpath
327
369
 
328
370
    @staticmethod
341
383
        """
342
384
        inv = self._inventory
343
385
        for path, ie in inv.iter_entries():
344
 
            if bzrlib.osutils.lexists(self.abspath(path)):
 
386
            if osutils.lexists(self.abspath(path)):
345
387
                yield ie.file_id
346
388
 
347
389
    def __repr__(self):
358
400
            try:
359
401
                xml = self.read_basis_inventory()
360
402
                inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
403
                inv.root.revision = revision_id
361
404
            except NoSuchFile:
362
405
                inv = None
363
406
            if inv is not None and inv.revision_id == revision_id:
383
426
        XXX: When BzrDir is present, these should be created through that 
384
427
        interface instead.
385
428
        """
386
 
        warn('delete WorkingTree.create', stacklevel=3)
 
429
        warnings.warn('delete WorkingTree.create', stacklevel=3)
387
430
        transport = get_transport(directory)
388
431
        if branch.bzrdir.root_transport.base == transport.base:
389
432
            # same dir 
404
447
        """
405
448
        return bzrdir.BzrDir.create_standalone_workingtree(directory)
406
449
 
407
 
    def relpath(self, abs):
408
 
        """Return the local path portion from a given absolute path."""
409
 
        return relpath(self.basedir, abs)
 
450
    def relpath(self, path):
 
451
        """Return the local path portion from a given path.
 
452
        
 
453
        The path may be absolute or relative. If its a relative path it is 
 
454
        interpreted relative to the python current working directory.
 
455
        """
 
456
        return relpath(self.basedir, path)
410
457
 
411
458
    def has_filename(self, filename):
412
 
        return bzrlib.osutils.lexists(self.abspath(filename))
 
459
        return osutils.lexists(self.abspath(filename))
413
460
 
414
461
    def get_file(self, file_id):
415
462
        return self.get_file_byname(self.id2path(file_id))
416
463
 
 
464
    def get_file_text(self, file_id):
 
465
        return self.get_file(file_id).read()
 
466
 
417
467
    def get_file_byname(self, filename):
418
468
        return file(self.abspath(filename), 'rb')
419
469
 
 
470
    def get_parent_ids(self):
 
471
        """See Tree.get_parent_ids.
 
472
        
 
473
        This implementation reads the pending merges list and last_revision
 
474
        value and uses that to decide what the parents list should be.
 
475
        """
 
476
        last_rev = self.last_revision()
 
477
        if last_rev is None:
 
478
            parents = []
 
479
        else:
 
480
            parents = [last_rev]
 
481
        other_parents = self.pending_merges()
 
482
        return parents + other_parents
 
483
 
420
484
    def get_root_id(self):
421
485
        """Return the id of this trees root"""
422
486
        inv = self.read_working_inventory()
471
535
        # but with branch a kwarg now, passing in args as is results in the
472
536
        #message being used for the branch
473
537
        args = (DEPRECATED_PARAMETER, message, ) + args
474
 
        Commit().commit(working_tree=self, revprops=revprops, *args, **kwargs)
 
538
        committed_id = Commit().commit( working_tree=self, revprops=revprops,
 
539
            *args, **kwargs)
475
540
        self._set_inventory(self.read_working_inventory())
 
541
        return committed_id
476
542
 
477
543
    def id2abspath(self, file_id):
478
544
        return self.abspath(self.id2path(file_id))
483
549
        if not inv.has_id(file_id):
484
550
            return False
485
551
        path = inv.id2path(file_id)
486
 
        return bzrlib.osutils.lexists(self.abspath(path))
 
552
        return osutils.lexists(self.abspath(path))
487
553
 
488
554
    def has_or_had_id(self, file_id):
489
555
        if file_id == self.inventory.root.file_id:
496
562
        return os.path.getsize(self.id2abspath(file_id))
497
563
 
498
564
    @needs_read_lock
499
 
    def get_file_sha1(self, file_id):
500
 
        path = self._inventory.id2path(file_id)
 
565
    def get_file_sha1(self, file_id, path=None):
 
566
        if not path:
 
567
            path = self._inventory.id2path(file_id)
501
568
        return self._hashcache.get_sha1(path)
502
569
 
503
 
    def is_executable(self, file_id):
504
 
        if not supports_executable():
 
570
    def get_file_mtime(self, file_id, path=None):
 
571
        if not path:
 
572
            path = self._inventory.id2path(file_id)
 
573
        return os.lstat(self.abspath(path)).st_mtime
 
574
 
 
575
    if not supports_executable():
 
576
        def is_executable(self, file_id, path=None):
505
577
            return self._inventory[file_id].executable
506
 
        else:
507
 
            path = self._inventory.id2path(file_id)
 
578
    else:
 
579
        def is_executable(self, file_id, path=None):
 
580
            if not path:
 
581
                path = self._inventory.id2path(file_id)
508
582
            mode = os.lstat(self.abspath(path)).st_mode
509
 
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC&mode)
 
583
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
510
584
 
511
585
    @needs_write_lock
512
586
    def add(self, files, ids=None):
547
621
        inv = self.read_working_inventory()
548
622
        for f,file_id in zip(files, ids):
549
623
            if self.is_control_filename(f):
550
 
                raise BzrError("cannot add control file %s" % quotefn(f))
 
624
                raise errors.ForbiddenControlFileError(filename=f)
551
625
 
552
626
            fp = splitpath(f)
553
627
 
555
629
                raise BzrError("cannot add top-level %r" % f)
556
630
 
557
631
            fullpath = normpath(self.abspath(f))
558
 
 
559
632
            try:
560
633
                kind = file_kind(fullpath)
561
634
            except OSError, e:
562
635
                if e.errno == errno.ENOENT:
563
636
                    raise NoSuchFile(fullpath)
564
 
                # maybe something better?
565
 
                raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
566
 
 
567
637
            if not InventoryEntry.versionable_kind(kind):
568
 
                raise BzrError('cannot add: not a versionable file ('
569
 
                               'i.e. regular file, symlink or directory): %s' % quotefn(f))
570
 
 
 
638
                raise errors.BadFileKindError(filename=f, kind=kind)
571
639
            if file_id is None:
572
 
                file_id = gen_file_id(f)
573
 
            inv.add_path(f, kind=kind, file_id=file_id)
 
640
                inv.add_path(f, kind=kind)
 
641
            else:
 
642
                inv.add_path(f, kind=kind, file_id=file_id)
574
643
 
575
 
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
576
644
        self._write_inventory(inv)
577
645
 
578
646
    @needs_write_lock
598
666
        """
599
667
        try:
600
668
            merges_file = self._control_files.get_utf8('pending-merges')
601
 
        except OSError, e:
602
 
            if e.errno != errno.ENOENT:
603
 
                raise
 
669
        except NoSuchFile:
604
670
            return []
605
671
        p = []
606
672
        for l in merges_file.readlines():
656
722
            return '?'
657
723
 
658
724
    def list_files(self):
659
 
        """Recursively list all files as (path, class, kind, id).
 
725
        """Recursively list all files as (path, class, kind, id, entry).
660
726
 
661
727
        Lists, but does not descend into unversioned directories.
662
728
 
666
732
        Skips the control directory.
667
733
        """
668
734
        inv = self._inventory
669
 
 
670
 
        def descend(from_dir_relpath, from_dir_id, dp):
671
 
            ls = os.listdir(dp)
672
 
            ls.sort()
673
 
            for f in ls:
 
735
        # Convert these into local objects to save lookup times
 
736
        pathjoin = osutils.pathjoin
 
737
        file_kind = osutils.file_kind
 
738
 
 
739
        # transport.base ends in a slash, we want the piece
 
740
        # between the last two slashes
 
741
        transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
 
742
 
 
743
        fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
 
744
 
 
745
        # directory file_id, relative path, absolute path, reverse sorted children
 
746
        children = os.listdir(self.basedir)
 
747
        children.sort()
 
748
        # jam 20060527 The kernel sized tree seems equivalent whether we 
 
749
        # use a deque and popleft to keep them sorted, or if we use a plain
 
750
        # list and just reverse() them.
 
751
        children = collections.deque(children)
 
752
        stack = [(inv.root.file_id, u'', self.basedir, children)]
 
753
        while stack:
 
754
            from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
 
755
 
 
756
            while children:
 
757
                f = children.popleft()
674
758
                ## TODO: If we find a subdirectory with its own .bzr
675
759
                ## directory, then that is a separate tree and we
676
760
                ## should exclude it.
677
761
 
678
762
                # the bzrdir for this tree
679
 
                if self.bzrdir.transport.base.endswith(f + '/'):
 
763
                if transport_base_dir == f:
680
764
                    continue
681
765
 
682
 
                # path within tree
683
 
                fp = appendpath(from_dir_relpath, f)
 
766
                # we know that from_dir_relpath and from_dir_abspath never end in a slash
 
767
                # and 'f' doesn't begin with one, we can do a string op, rather
 
768
                # than the checks of pathjoin(), all relative paths will have an extra slash
 
769
                # at the beginning
 
770
                fp = from_dir_relpath + '/' + f
684
771
 
685
772
                # absolute path
686
 
                fap = appendpath(dp, f)
 
773
                fap = from_dir_abspath + '/' + f
687
774
                
688
775
                f_ie = inv.get_child(from_dir_id, f)
689
776
                if f_ie:
690
777
                    c = 'V'
691
 
                elif self.is_ignored(fp):
 
778
                elif self.is_ignored(fp[1:]):
692
779
                    c = 'I'
693
780
                else:
694
 
                    c = '?'
 
781
                    # we may not have found this file, because of a unicode issue
 
782
                    f_norm, can_access = osutils.normalized_filename(f)
 
783
                    if f == f_norm or not can_access:
 
784
                        # No change, so treat this file normally
 
785
                        c = '?'
 
786
                    else:
 
787
                        # this file can be accessed by a normalized path
 
788
                        # check again if it is versioned
 
789
                        # these lines are repeated here for performance
 
790
                        f = f_norm
 
791
                        fp = from_dir_relpath + '/' + f
 
792
                        fap = from_dir_abspath + '/' + f
 
793
                        f_ie = inv.get_child(from_dir_id, f)
 
794
                        if f_ie:
 
795
                            c = 'V'
 
796
                        elif self.is_ignored(fp[1:]):
 
797
                            c = 'I'
 
798
                        else:
 
799
                            c = '?'
695
800
 
696
801
                fk = file_kind(fap)
697
802
 
703
808
 
704
809
                # make a last minute entry
705
810
                if f_ie:
706
 
                    entry = f_ie
 
811
                    yield fp[1:], c, fk, f_ie.file_id, f_ie
707
812
                else:
708
 
                    if fk == 'directory':
709
 
                        entry = TreeDirectory()
710
 
                    elif fk == 'file':
711
 
                        entry = TreeFile()
712
 
                    elif fk == 'symlink':
713
 
                        entry = TreeLink()
714
 
                    else:
715
 
                        entry = TreeEntry()
 
813
                    try:
 
814
                        yield fp[1:], c, fk, None, fk_entries[fk]()
 
815
                    except KeyError:
 
816
                        yield fp[1:], c, fk, None, TreeEntry()
 
817
                    continue
716
818
                
717
 
                yield fp, c, fk, (f_ie and f_ie.file_id), entry
718
 
 
719
819
                if fk != 'directory':
720
820
                    continue
721
821
 
722
 
                if c != 'V':
723
 
                    # don't descend unversioned directories
724
 
                    continue
725
 
                
726
 
                for ff in descend(fp, f_ie.file_id, fap):
727
 
                    yield ff
 
822
                # But do this child first
 
823
                new_children = os.listdir(fap)
 
824
                new_children.sort()
 
825
                new_children = collections.deque(new_children)
 
826
                stack.append((f_ie.file_id, fp, fap, new_children))
 
827
                # Break out of inner loop, so that we start outer loop with child
 
828
                break
 
829
            else:
 
830
                # if we finished all children, pop it off the stack
 
831
                stack.pop()
728
832
 
729
 
        for f in descend(u'', inv.root.file_id, self.basedir):
730
 
            yield f
731
833
 
732
834
    @needs_write_lock
733
835
    def move(self, from_paths, to_name):
757
859
        if to_dir_id == None and to_name != '':
758
860
            raise BzrError("destination %r is not a versioned directory" % to_name)
759
861
        to_dir_ie = inv[to_dir_id]
760
 
        if to_dir_ie.kind not in ('directory', 'root_directory'):
 
862
        if to_dir_ie.kind != 'directory':
761
863
            raise BzrError("destination %r is not a directory" % to_abs)
762
864
 
763
865
        to_idpath = inv.get_idpath(to_dir_id)
769
871
            if f_id == None:
770
872
                raise BzrError("%r is not versioned" % f)
771
873
            name_tail = splitpath(f)[-1]
772
 
            dest_path = appendpath(to_name, name_tail)
 
874
            dest_path = pathjoin(to_name, name_tail)
773
875
            if self.has_filename(dest_path):
774
876
                raise BzrError("destination %r already exists" % dest_path)
775
877
            if f_id in to_idpath:
782
884
        try:
783
885
            for f in from_paths:
784
886
                name_tail = splitpath(f)[-1]
785
 
                dest_path = appendpath(to_name, name_tail)
 
887
                dest_path = pathjoin(to_name, name_tail)
786
888
                result.append((f, dest_path))
787
889
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
788
890
                try:
852
954
 
853
955
        These are files in the working directory that are not versioned or
854
956
        control files or ignored.
855
 
        
856
 
        >>> from bzrlib.bzrdir import ScratchDir
857
 
        >>> d = ScratchDir(files=['foo', 'foo~'])
858
 
        >>> b = d.open_branch()
859
 
        >>> tree = d.open_workingtree()
860
 
        >>> map(str, tree.unknowns())
861
 
        ['foo']
862
 
        >>> tree.add('foo')
863
 
        >>> list(b.unknowns())
864
 
        []
865
 
        >>> tree.remove('foo')
866
 
        >>> list(b.unknowns())
867
 
        [u'foo']
868
957
        """
869
958
        for subp in self.extras():
870
959
            if not self.is_ignored(subp):
878
967
 
879
968
    def _iter_conflicts(self):
880
969
        conflicted = set()
881
 
        for path in (s[0] for s in self.list_files()):
 
970
        for info in self.list_files():
 
971
            path = info[0]
882
972
            stem = get_conflicted_stem(path)
883
973
            if stem is None:
884
974
                continue
930
1020
        """
931
1021
        ## TODO: Work from given directory downwards
932
1022
        for path, dir_entry in self.inventory.directories():
933
 
            mutter("search for unknowns in %r", path)
 
1023
            # mutter("search for unknowns in %r", path)
934
1024
            dirabs = self.abspath(path)
935
1025
            if not isdir(dirabs):
936
1026
                # e.g. directory deleted
938
1028
 
939
1029
            fl = []
940
1030
            for subf in os.listdir(dirabs):
941
 
                if (subf != '.bzr'
942
 
                    and (subf not in dir_entry.children)):
943
 
                    fl.append(subf)
 
1031
                if subf == '.bzr':
 
1032
                    continue
 
1033
                if subf not in dir_entry.children:
 
1034
                    subf_norm, can_access = osutils.normalized_filename(subf)
 
1035
                    if subf_norm != subf and can_access:
 
1036
                        if subf_norm not in dir_entry.children:
 
1037
                            fl.append(subf_norm)
 
1038
                    else:
 
1039
                        fl.append(subf)
944
1040
            
945
1041
            fl.sort()
946
1042
            for subf in fl:
947
 
                subp = appendpath(path, subf)
 
1043
                subp = pathjoin(path, subf)
948
1044
                yield subp
949
1045
 
 
1046
    def _translate_ignore_rule(self, rule):
 
1047
        """Translate a single ignore rule to a regex.
 
1048
 
 
1049
        There are two types of ignore rules.  Those that do not contain a / are
 
1050
        matched against the tail of the filename (that is, they do not care
 
1051
        what directory the file is in.)  Rules which do contain a slash must
 
1052
        match the entire path.  As a special case, './' at the start of the
 
1053
        string counts as a slash in the string but is removed before matching
 
1054
        (e.g. ./foo.c, ./src/foo.c)
 
1055
 
 
1056
        :return: The translated regex.
 
1057
        """
 
1058
        if rule[:2] in ('./', '.\\'):
 
1059
            # rootdir rule
 
1060
            result = fnmatch.translate(rule[2:])
 
1061
        elif '/' in rule or '\\' in rule:
 
1062
            # path prefix 
 
1063
            result = fnmatch.translate(rule)
 
1064
        else:
 
1065
            # default rule style.
 
1066
            result = "(?:.*/)?(?!.*/)" + fnmatch.translate(rule)
 
1067
        assert result[-1] == '$', "fnmatch.translate did not add the expected $"
 
1068
        return "(" + result + ")"
 
1069
 
 
1070
    def _combine_ignore_rules(self, rules):
 
1071
        """Combine a list of ignore rules into a single regex object.
 
1072
 
 
1073
        Each individual rule is combined with | to form a big regex, which then
 
1074
        has $ added to it to form something like ()|()|()$. The group index for
 
1075
        each subregex's outermost group is placed in a dictionary mapping back 
 
1076
        to the rule. This allows quick identification of the matching rule that
 
1077
        triggered a match.
 
1078
        :return: a list of the compiled regex and the matching-group index 
 
1079
        dictionaries. We return a list because python complains if you try to 
 
1080
        combine more than 100 regexes.
 
1081
        """
 
1082
        result = []
 
1083
        groups = {}
 
1084
        next_group = 0
 
1085
        translated_rules = []
 
1086
        for rule in rules:
 
1087
            translated_rule = self._translate_ignore_rule(rule)
 
1088
            compiled_rule = re.compile(translated_rule)
 
1089
            groups[next_group] = rule
 
1090
            next_group += compiled_rule.groups
 
1091
            translated_rules.append(translated_rule)
 
1092
            if next_group == 99:
 
1093
                result.append((re.compile("|".join(translated_rules)), groups))
 
1094
                groups = {}
 
1095
                next_group = 0
 
1096
                translated_rules = []
 
1097
        if len(translated_rules):
 
1098
            result.append((re.compile("|".join(translated_rules)), groups))
 
1099
        return result
950
1100
 
951
1101
    def ignored_files(self):
952
1102
        """Yield list of PATH, IGNORE_PATTERN"""
955
1105
            if pat != None:
956
1106
                yield subp, pat
957
1107
 
958
 
 
959
1108
    def get_ignore_list(self):
960
1109
        """Return list of ignore patterns.
961
1110
 
962
1111
        Cached in the Tree object after the first call.
963
1112
        """
964
 
        if hasattr(self, '_ignorelist'):
965
 
            return self._ignorelist
966
 
 
967
 
        l = bzrlib.DEFAULT_IGNORE[:]
 
1113
        ignoreset = getattr(self, '_ignoreset', None)
 
1114
        if ignoreset is not None:
 
1115
            return ignoreset
 
1116
 
 
1117
        ignore_globs = set(bzrlib.DEFAULT_IGNORE)
 
1118
        ignore_globs.update(ignores.get_runtime_ignores())
 
1119
 
 
1120
        ignore_globs.update(ignores.get_user_ignores())
 
1121
 
968
1122
        if self.has_filename(bzrlib.IGNORE_FILENAME):
969
1123
            f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
970
 
            l.extend([line.rstrip("\n\r") for line in f.readlines()])
971
 
        self._ignorelist = l
972
 
        return l
973
 
 
 
1124
            try:
 
1125
                ignore_globs.update(ignores.parse_ignore_file(f))
 
1126
            finally:
 
1127
                f.close()
 
1128
 
 
1129
        self._ignoreset = ignore_globs
 
1130
        self._ignore_regex = self._combine_ignore_rules(ignore_globs)
 
1131
        return ignore_globs
 
1132
 
 
1133
    def _get_ignore_rules_as_regex(self):
 
1134
        """Return a regex of the ignore rules and a mapping dict.
 
1135
 
 
1136
        :return: (ignore rules compiled regex, dictionary mapping rule group 
 
1137
        indices to original rule.)
 
1138
        """
 
1139
        if getattr(self, '_ignoreset', None) is None:
 
1140
            self.get_ignore_list()
 
1141
        return self._ignore_regex
974
1142
 
975
1143
    def is_ignored(self, filename):
976
1144
        r"""Check whether the filename matches an ignore pattern.
990
1158
        # treat dotfiles correctly and allows * to match /.
991
1159
        # Eventually it should be replaced with something more
992
1160
        # accurate.
993
 
        
994
 
        for pat in self.get_ignore_list():
995
 
            if '/' in pat or '\\' in pat:
996
 
                
997
 
                # as a special case, you can put ./ at the start of a
998
 
                # pattern; this is good to match in the top-level
999
 
                # only;
1000
 
                
1001
 
                if (pat[:2] == './') or (pat[:2] == '.\\'):
1002
 
                    newpat = pat[2:]
1003
 
                else:
1004
 
                    newpat = pat
1005
 
                if fnmatch.fnmatchcase(filename, newpat):
1006
 
                    return pat
1007
 
            else:
1008
 
                if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
1009
 
                    return pat
1010
 
        else:
1011
 
            return None
 
1161
    
 
1162
        rules = self._get_ignore_rules_as_regex()
 
1163
        for regex, mapping in rules:
 
1164
            match = regex.match(filename)
 
1165
            if match is not None:
 
1166
                # one or more of the groups in mapping will have a non-None group 
 
1167
                # match.
 
1168
                groups = match.groups()
 
1169
                rules = [mapping[group] for group in 
 
1170
                    mapping if groups[group] is not None]
 
1171
                return rules[0]
 
1172
        return None
1012
1173
 
1013
1174
    def kind(self, file_id):
1014
1175
        return file_kind(self.id2abspath(file_id))
1023
1184
        """
1024
1185
        return self.branch.last_revision()
1025
1186
 
 
1187
    def is_locked(self):
 
1188
        return self._control_files.is_locked()
 
1189
 
1026
1190
    def lock_read(self):
1027
1191
        """See Branch.lock_read, and WorkingTree.unlock."""
1028
1192
        self.branch.lock_read()
1041
1205
            self.branch.unlock()
1042
1206
            raise
1043
1207
 
 
1208
    def get_physical_lock_status(self):
 
1209
        return self._control_files.get_physical_lock_status()
 
1210
 
1044
1211
    def _basis_inventory_name(self):
1045
1212
        return 'basis-inventory'
1046
1213
 
1059
1226
        if new_revision is None:
1060
1227
            self.branch.set_revision_history([])
1061
1228
            return False
1062
 
        # current format is locked in with the branch
1063
 
        revision_history = self.branch.revision_history()
1064
1229
        try:
1065
 
            position = revision_history.index(new_revision)
1066
 
        except ValueError:
1067
 
            raise errors.NoSuchRevision(self.branch, new_revision)
1068
 
        self.branch.set_revision_history(revision_history[:position + 1])
 
1230
            self.branch.generate_revision_history(new_revision)
 
1231
        except errors.NoSuchRevision:
 
1232
            # not present in the repo - dont try to set it deeper than the tip
 
1233
            self.branch.set_revision_history([new_revision])
1069
1234
        return True
1070
1235
 
1071
1236
    def _cache_basis_inventory(self, new_revision):
1072
1237
        """Cache new_revision as the basis inventory."""
 
1238
        # TODO: this should allow the ready-to-use inventory to be passed in,
 
1239
        # as commit already has that ready-to-use [while the format is the
 
1240
        # same, that is].
1073
1241
        try:
1074
1242
            # this double handles the inventory - unpack and repack - 
1075
1243
            # but is easier to understand. We can/should put a conditional
1076
1244
            # in here based on whether the inventory is in the latest format
1077
1245
            # - perhaps we should repack all inventories on a repository
1078
1246
            # upgrade ?
1079
 
            inv = self.branch.repository.get_inventory(new_revision)
1080
 
            inv.revision_id = new_revision
1081
 
            xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
1082
 
 
 
1247
            # the fast path is to copy the raw xml from the repository. If the
 
1248
            # xml contains 'revision_id="', then we assume the right 
 
1249
            # revision_id is set. We must check for this full string, because a
 
1250
            # root node id can legitimately look like 'revision_id' but cannot
 
1251
            # contain a '"'.
 
1252
            xml = self.branch.repository.get_inventory_xml(new_revision)
 
1253
            if not 'revision_id="' in xml.split('\n', 1)[0]:
 
1254
                inv = self.branch.repository.deserialise_inventory(
 
1255
                    new_revision, xml)
 
1256
                inv.revision_id = new_revision
 
1257
                xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
 
1258
            assert isinstance(xml, str), 'serialised xml must be bytestring.'
1083
1259
            path = self._basis_inventory_name()
1084
 
            self._control_files.put_utf8(path, xml)
1085
 
        except WeaveRevisionNotPresent:
 
1260
            sio = StringIO(xml)
 
1261
            self._control_files.put(path, sio)
 
1262
        except (errors.NoSuchRevision, errors.RevisionNotPresent):
1086
1263
            pass
1087
1264
 
1088
1265
    def read_basis_inventory(self):
1089
1266
        """Read the cached basis inventory."""
1090
1267
        path = self._basis_inventory_name()
1091
 
        return self._control_files.get_utf8(path).read()
 
1268
        return self._control_files.get(path).read()
1092
1269
        
1093
1270
    @needs_read_lock
1094
1271
    def read_working_inventory(self):
1101
1278
        return result
1102
1279
 
1103
1280
    @needs_write_lock
1104
 
    def remove(self, files, verbose=False):
 
1281
    def remove(self, files, verbose=False, to_file=None):
1105
1282
        """Remove nominated files from the working inventory..
1106
1283
 
1107
1284
        This does not remove their text.  This does not run on XXX on what? RBC
1129
1306
                # TODO: Perhaps make this just a warning, and continue?
1130
1307
                # This tends to happen when 
1131
1308
                raise NotVersionedError(path=f)
1132
 
            mutter("remove inventory entry %s {%s}", quotefn(f), fid)
1133
1309
            if verbose:
1134
1310
                # having remove it, it must be either ignored or unknown
1135
1311
                if self.is_ignored(f):
1136
1312
                    new_status = 'I'
1137
1313
                else:
1138
1314
                    new_status = '?'
1139
 
                show_status(new_status, inv[fid].kind, quotefn(f))
 
1315
                show_status(new_status, inv[fid].kind, f, to_file=to_file)
1140
1316
            del inv[fid]
1141
1317
 
1142
1318
        self._write_inventory(inv)
1204
1380
        between multiple working trees, i.e. via shared storage, then we 
1205
1381
        would probably want to lock both the local tree, and the branch.
1206
1382
        """
1207
 
        # FIXME: We want to write out the hashcache only when the last lock on
1208
 
        # this working copy is released.  Peeking at the lock count is a bit
1209
 
        # of a nasty hack; probably it's better to have a transaction object,
1210
 
        # which can do some finalization when it's either successfully or
1211
 
        # unsuccessfully completed.  (Denys's original patch did that.)
1212
 
        # RBC 20060206 hookinhg into transaction will couple lock and transaction
1213
 
        # wrongly. Hookinh into unllock on the control files object is fine though.
1214
 
        
1215
 
        # TODO: split this per format so there is no ugly if block
1216
 
        if self._hashcache.needs_write and (
1217
 
            # dedicated lock files
1218
 
            self._control_files._lock_count==1 or 
1219
 
            # shared lock files
1220
 
            (self._control_files is self.branch.control_files and 
1221
 
             self._control_files._lock_count==3)):
1222
 
            self._hashcache.write()
1223
 
        # reverse order of locking.
1224
 
        result = self._control_files.unlock()
1225
 
        try:
1226
 
            self.branch.unlock()
1227
 
        finally:
1228
 
            return result
 
1383
        raise NotImplementedError(self.unlock)
1229
1384
 
1230
1385
    @needs_write_lock
1231
1386
    def update(self):
1263
1418
                                      this_tree=self)
1264
1419
                self.set_last_revision(self.branch.last_revision())
1265
1420
            if old_tip and old_tip != self.last_revision():
1266
 
                # our last revision was not the prior branch last reivison
 
1421
                # our last revision was not the prior branch last revision
1267
1422
                # and we have converted that last revision to a pending merge.
1268
1423
                # base is somewhere between the branch tip now
1269
1424
                # and the now pending merge
1297
1452
    def set_conflicts(self, arg):
1298
1453
        raise UnsupportedOperation(self.set_conflicts, self)
1299
1454
 
 
1455
    def add_conflicts(self, arg):
 
1456
        raise UnsupportedOperation(self.add_conflicts, self)
 
1457
 
1300
1458
    @needs_read_lock
1301
1459
    def conflicts(self):
1302
1460
        conflicts = ConflictList()
1305
1463
            try:
1306
1464
                if file_kind(self.abspath(conflicted)) != "file":
1307
1465
                    text = False
1308
 
            except OSError, e:
1309
 
                if e.errno == errno.ENOENT:
1310
 
                    text = False
1311
 
                else:
1312
 
                    raise
 
1466
            except errors.NoSuchFile:
 
1467
                text = False
1313
1468
            if text is True:
1314
1469
                for suffix in ('.THIS', '.OTHER'):
1315
1470
                    try:
1316
1471
                        kind = file_kind(self.abspath(conflicted+suffix))
1317
 
                    except OSError, e:
1318
 
                        if e.errno == errno.ENOENT:
 
1472
                        if kind != "file":
1319
1473
                            text = False
1320
 
                            break
1321
 
                        else:
1322
 
                            raise
1323
 
                    if kind != "file":
 
1474
                    except errors.NoSuchFile:
1324
1475
                        text = False
 
1476
                    if text == False:
1325
1477
                        break
1326
1478
            ctype = {True: 'text conflict', False: 'contents conflict'}[text]
1327
1479
            conflicts.append(Conflict.factory(ctype, path=conflicted,
1329
1481
        return conflicts
1330
1482
 
1331
1483
 
 
1484
class WorkingTree2(WorkingTree):
 
1485
    """This is the Format 2 working tree.
 
1486
 
 
1487
    This was the first weave based working tree. 
 
1488
     - uses os locks for locking.
 
1489
     - uses the branch last-revision.
 
1490
    """
 
1491
 
 
1492
    def unlock(self):
 
1493
        # we share control files:
 
1494
        if self._hashcache.needs_write and self._control_files._lock_count==3:
 
1495
            self._hashcache.write()
 
1496
        # reverse order of locking.
 
1497
        try:
 
1498
            return self._control_files.unlock()
 
1499
        finally:
 
1500
            self.branch.unlock()
 
1501
 
 
1502
 
1332
1503
class WorkingTree3(WorkingTree):
1333
1504
    """This is the Format 3 working tree.
1334
1505
 
1356
1527
                pass
1357
1528
            return False
1358
1529
        else:
1359
 
            try:
1360
 
                self.branch.revision_history().index(revision_id)
1361
 
            except ValueError:
1362
 
                raise errors.NoSuchRevision(self.branch, revision_id)
1363
1530
            self._control_files.put_utf8('last-revision', revision_id)
1364
1531
            return True
1365
1532
 
1368
1535
        self._put_rio('conflicts', conflicts.to_stanzas(), 
1369
1536
                      CONFLICT_HEADER_1)
1370
1537
 
 
1538
    @needs_write_lock
 
1539
    def add_conflicts(self, new_conflicts):
 
1540
        conflict_set = set(self.conflicts())
 
1541
        conflict_set.update(set(list(new_conflicts)))
 
1542
        self.set_conflicts(ConflictList(sorted(conflict_set,
 
1543
                                               key=Conflict.sort_key)))
 
1544
 
1371
1545
    @needs_read_lock
1372
1546
    def conflicts(self):
1373
1547
        try:
1381
1555
            raise ConflictFormatError()
1382
1556
        return ConflictList.from_stanzas(RioReader(confile))
1383
1557
 
 
1558
    def unlock(self):
 
1559
        if self._hashcache.needs_write and self._control_files._lock_count==1:
 
1560
            self._hashcache.write()
 
1561
        # reverse order of locking.
 
1562
        try:
 
1563
            return self._control_files.unlock()
 
1564
        finally:
 
1565
            self.branch.unlock()
 
1566
 
1384
1567
 
1385
1568
def get_conflicted_stem(path):
1386
1569
    for suffix in CONFLICT_SUFFIXES:
1437
1620
        except NoSuchFile:
1438
1621
            raise errors.NoWorkingTree(base=transport.base)
1439
1622
        except KeyError:
1440
 
            raise errors.UnknownFormatError(format_string)
 
1623
            raise errors.UnknownFormatError(format=format_string)
1441
1624
 
1442
1625
    @classmethod
1443
1626
    def get_default_format(klass):
1486
1669
        """See WorkingTreeFormat.get_format_description()."""
1487
1670
        return "Working tree format 2"
1488
1671
 
 
1672
    def stub_initialize_remote(self, control_files):
 
1673
        """As a special workaround create critical control files for a remote working tree
 
1674
        
 
1675
        This ensures that it can later be updated and dealt with locally,
 
1676
        since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with 
 
1677
        no working tree.  (See bug #43064).
 
1678
        """
 
1679
        sio = StringIO()
 
1680
        inv = Inventory()
 
1681
        bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
 
1682
        sio.seek(0)
 
1683
        control_files.put('inventory', sio)
 
1684
 
 
1685
        control_files.put_utf8('pending-merges', '')
 
1686
        
 
1687
 
1489
1688
    def initialize(self, a_bzrdir, revision_id=None):
1490
1689
        """See WorkingTreeFormat.initialize()."""
1491
1690
        if not isinstance(a_bzrdir.transport, LocalTransport):
1504
1703
                branch.unlock()
1505
1704
        revision = branch.last_revision()
1506
1705
        inv = Inventory() 
1507
 
        wt = WorkingTree(a_bzrdir.root_transport.base,
 
1706
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
1508
1707
                         branch,
1509
1708
                         inv,
1510
1709
                         _internal=True,
1532
1731
            raise NotImplementedError
1533
1732
        if not isinstance(a_bzrdir.transport, LocalTransport):
1534
1733
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
1535
 
        return WorkingTree(a_bzrdir.root_transport.base,
 
1734
        return WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
1536
1735
                           _internal=True,
1537
1736
                           _format=self,
1538
1737
                           _bzrdir=a_bzrdir)
1547
1746
          files, separate from the BzrDir format
1548
1747
        - modifies the hash cache format
1549
1748
        - is new in bzr 0.8
1550
 
        - uses a LockDir to guard access to the repository
 
1749
        - uses a LockDir to guard access for writes.
1551
1750
    """
1552
1751
 
1553
1752
    def get_format_string(self):
1569
1768
    def initialize(self, a_bzrdir, revision_id=None):
1570
1769
        """See WorkingTreeFormat.initialize().
1571
1770
        
1572
 
        revision_id allows creating a working tree at a differnet
 
1771
        revision_id allows creating a working tree at a different
1573
1772
        revision than the branch is at.
1574
1773
        """
1575
1774
        if not isinstance(a_bzrdir.transport, LocalTransport):
1577
1776
        transport = a_bzrdir.get_workingtree_transport(self)
1578
1777
        control_files = self._open_control_files(a_bzrdir)
1579
1778
        control_files.create_lock()
 
1779
        control_files.lock_write()
1580
1780
        control_files.put_utf8('format', self.get_format_string())
1581
1781
        branch = a_bzrdir.open_branch()
1582
1782
        if revision_id is None:
1583
1783
            revision_id = branch.last_revision()
1584
1784
        inv = Inventory() 
1585
 
        wt = WorkingTree3(a_bzrdir.root_transport.base,
 
1785
        wt = WorkingTree3(a_bzrdir.root_transport.local_abspath('.'),
1586
1786
                         branch,
1587
1787
                         inv,
1588
1788
                         _internal=True,
1589
1789
                         _format=self,
1590
1790
                         _bzrdir=a_bzrdir,
1591
1791
                         _control_files=control_files)
1592
 
        wt._write_inventory(inv)
1593
 
        wt.set_root_id(inv.root.file_id)
1594
 
        wt.set_last_revision(revision_id)
1595
 
        wt.set_pending_merges([])
1596
 
        build_tree(wt.basis_tree(), wt)
 
1792
        wt.lock_write()
 
1793
        try:
 
1794
            wt._write_inventory(inv)
 
1795
            wt.set_root_id(inv.root.file_id)
 
1796
            wt.set_last_revision(revision_id)
 
1797
            wt.set_pending_merges([])
 
1798
            build_tree(wt.basis_tree(), wt)
 
1799
        finally:
 
1800
            wt.unlock()
 
1801
            control_files.unlock()
1597
1802
        return wt
1598
1803
 
1599
1804
    def __init__(self):
1611
1816
            raise NotImplementedError
1612
1817
        if not isinstance(a_bzrdir.transport, LocalTransport):
1613
1818
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
1614
 
        control_files = self._open_control_files(a_bzrdir)
1615
 
        return WorkingTree3(a_bzrdir.root_transport.base,
 
1819
        return self._open(a_bzrdir, self._open_control_files(a_bzrdir))
 
1820
 
 
1821
    def _open(self, a_bzrdir, control_files):
 
1822
        """Open the tree itself.
 
1823
        
 
1824
        :param a_bzrdir: the dir for the tree.
 
1825
        :param control_files: the control files for the tree.
 
1826
        """
 
1827
        return WorkingTree3(a_bzrdir.root_transport.local_abspath('.'),
1616
1828
                           _internal=True,
1617
1829
                           _format=self,
1618
1830
                           _bzrdir=a_bzrdir,
1645
1857
        self._transport_readonly_server = transport_readonly_server
1646
1858
        self._formats = formats
1647
1859
    
 
1860
    def _clone_test(self, test, bzrdir_format, workingtree_format, variation):
 
1861
        """Clone test for adaption."""
 
1862
        new_test = deepcopy(test)
 
1863
        new_test.transport_server = self._transport_server
 
1864
        new_test.transport_readonly_server = self._transport_readonly_server
 
1865
        new_test.bzrdir_format = bzrdir_format
 
1866
        new_test.workingtree_format = workingtree_format
 
1867
        def make_new_test_id():
 
1868
            new_id = "%s(%s)" % (test.id(), variation)
 
1869
            return lambda: new_id
 
1870
        new_test.id = make_new_test_id()
 
1871
        return new_test
 
1872
    
1648
1873
    def adapt(self, test):
1649
1874
        from bzrlib.tests import TestSuite
1650
1875
        result = TestSuite()
1651
1876
        for workingtree_format, bzrdir_format in self._formats:
1652
 
            new_test = deepcopy(test)
1653
 
            new_test.transport_server = self._transport_server
1654
 
            new_test.transport_readonly_server = self._transport_readonly_server
1655
 
            new_test.bzrdir_format = bzrdir_format
1656
 
            new_test.workingtree_format = workingtree_format
1657
 
            def make_new_test_id():
1658
 
                new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
1659
 
                return lambda: new_id
1660
 
            new_test.id = make_new_test_id()
 
1877
            new_test = self._clone_test(
 
1878
                test,
 
1879
                bzrdir_format,
 
1880
                workingtree_format, workingtree_format.__class__.__name__)
1661
1881
            result.addTest(new_test)
1662
1882
        return result