← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Robert Collins
  • Date: 2006-03-02 03:12:34 UTC
  • mto: (1594.2.4 integration)
  • mto: This revision was merged to the branch mainline in revision 1596.
  • Revision ID: robertc@robertcollins.net-20060302031234-cf6b75961f27c5df
InterVersionedFile implemented.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
25
25
At the moment every WorkingTree has its own branch.  Remote
26
26
WorkingTrees aren't supported.
27
27
 
28
 
To get a WorkingTree, call Branch.working_tree():
 
28
To get a WorkingTree, call bzrdir.open_workingtree() or
 
29
WorkingTree.open(dir).
29
30
"""
30
31
 
31
32
 
32
 
# TODO: Don't allow WorkingTrees to be constructed for remote branches if 
33
 
# they don't work.
34
 
 
35
33
# FIXME: I don't know if writing out the cache from the destructor is really a
36
34
# good idea, because destructors are considered poor taste in Python, and it's
37
35
# not predictable when it will be written out.
43
41
# At the momenthey may alias the inventory and have old copies of it in memory.
44
42
 
45
43
from copy import deepcopy
 
44
from cStringIO import StringIO
 
45
import errno
 
46
import fnmatch
46
47
import os
47
48
import stat
48
 
import fnmatch
49
49
 
 
50
 
 
51
from bzrlib.atomicfile import AtomicFile
50
52
from bzrlib.branch import (Branch,
51
 
                           is_control_file,
52
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
53
57
from bzrlib.errors import (BzrCheckError,
54
58
                           BzrError,
55
59
                           DivergedBranches,
57
61
                           NotBranchError,
58
62
                           NoSuchFile,
59
63
                           NotVersionedError)
60
 
from bzrlib.inventory import InventoryEntry
 
64
from bzrlib.inventory import InventoryEntry, Inventory
 
65
from bzrlib.lockable_files import LockableFiles
 
66
from bzrlib.merge import merge_inner, transform_tree
61
67
from bzrlib.osutils import (appendpath,
62
68
                            compact_date,
63
69
                            file_kind,
65
71
                            getcwd,
66
72
                            pathjoin,
67
73
                            pumpfile,
 
74
                            safe_unicode,
68
75
                            splitpath,
69
76
                            rand_bytes,
70
77
                            abspath,
71
78
                            normpath,
72
79
                            realpath,
73
80
                            relpath,
74
 
                            rename)
 
81
                            rename,
 
82
                            supports_executable,
 
83
                            )
 
84
from bzrlib.progress import DummyProgress
 
85
from bzrlib.revision import NULL_REVISION
 
86
from bzrlib.symbol_versioning import *
75
87
from bzrlib.textui import show_status
76
88
import bzrlib.tree
77
89
from bzrlib.trace import mutter
 
90
from bzrlib.transform import build_tree
 
91
from bzrlib.transport import get_transport
 
92
from bzrlib.transport.local import LocalTransport
 
93
import bzrlib.ui
78
94
import bzrlib.xml5
79
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
80
95
 
81
96
 
82
97
def gen_file_id(name):
178
193
    not listed in the Inventory and vice versa.
179
194
    """
180
195
 
181
 
    def __init__(self, basedir=u'.', branch=None):
 
196
    def __init__(self, basedir='.',
 
197
                 branch=DEPRECATED_PARAMETER,
 
198
                 _inventory=None,
 
199
                 _control_files=None,
 
200
                 _internal=False,
 
201
                 _format=None,
 
202
                 _bzrdir=None):
182
203
        """Construct a WorkingTree for basedir.
183
204
 
184
205
        If the branch is not supplied, it is opened automatically.
186
207
        (branch.base is not cross checked, because for remote branches that
187
208
        would be meaningless).
188
209
        """
 
210
        self._format = _format
 
211
        self.bzrdir = _bzrdir
 
212
        if not _internal:
 
213
            # not created via open etc.
 
214
            warn("WorkingTree() is deprecated as of bzr version 0.8. "
 
215
                 "Please use bzrdir.open_workingtree or WorkingTree.open().",
 
216
                 DeprecationWarning,
 
217
                 stacklevel=2)
 
218
            wt = WorkingTree.open(basedir)
 
219
            self.branch = wt.branch
 
220
            self.basedir = wt.basedir
 
221
            self._control_files = wt._control_files
 
222
            self._hashcache = wt._hashcache
 
223
            self._set_inventory(wt._inventory)
 
224
            self._format = wt._format
 
225
            self.bzrdir = wt.bzrdir
189
226
        from bzrlib.hashcache import HashCache
190
227
        from bzrlib.trace import note, mutter
191
228
        assert isinstance(basedir, basestring), \
192
229
            "base directory %r is not a string" % basedir
193
 
        if branch is None:
194
 
            branch = Branch.open(basedir)
195
 
        assert isinstance(branch, Branch), \
196
 
            "branch %r is not a Branch" % branch
197
 
        self.branch = branch
 
230
        basedir = safe_unicode(basedir)
 
231
        mutter("opening working tree %r", basedir)
 
232
        if deprecated_passed(branch):
 
233
            if not _internal:
 
234
                warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
 
235
                     " Please use bzrdir.open_workingtree() or WorkingTree.open().",
 
236
                     DeprecationWarning,
 
237
                     stacklevel=2
 
238
                     )
 
239
            self.branch = branch
 
240
        else:
 
241
            self.branch = self.bzrdir.open_branch()
 
242
        assert isinstance(self.branch, Branch), \
 
243
            "branch %r is not a Branch" % self.branch
198
244
        self.basedir = realpath(basedir)
 
245
        # if branch is at our basedir and is a format 6 or less
 
246
        if isinstance(self._format, WorkingTreeFormat2):
 
247
            # share control object
 
248
            self._control_files = self.branch.control_files
 
249
        elif _control_files is not None:
 
250
            assert False, "not done yet"
 
251
#            self._control_files = _control_files
 
252
        else:
 
253
            # only ready for format 3
 
254
            assert isinstance(self._format, WorkingTreeFormat3)
 
255
            self._control_files = LockableFiles(
 
256
                self.bzrdir.get_workingtree_transport(None),
 
257
                'lock')
199
258
 
200
259
        # update the whole cache up front and write to disk if anything changed;
201
260
        # in the future we might want to do this more selectively
203
262
        # if needed, or, when the cache sees a change, append it to the hash
204
263
        # cache file, and have the parser take the most recent entry for a
205
264
        # given path only.
206
 
        hc = self._hashcache = HashCache(basedir)
 
265
        cache_filename = self.bzrdir.get_workingtree_transport(None).abspath('stat-cache')
 
266
        hc = self._hashcache = HashCache(basedir, cache_filename, self._control_files._file_mode)
207
267
        hc.read()
 
268
        # is this scan needed ? it makes things kinda slow.
208
269
        hc.scan()
209
270
 
210
271
        if hc.needs_write:
211
272
            mutter("write hc")
212
273
            hc.write()
213
274
 
214
 
        self._set_inventory(self.read_working_inventory())
 
275
        if _inventory is None:
 
276
            self._set_inventory(self.read_working_inventory())
 
277
        else:
 
278
            self._set_inventory(_inventory)
215
279
 
216
280
    def _set_inventory(self, inv):
217
281
        self._inventory = inv
218
282
        self.path2id = self._inventory.path2id
219
283
 
 
284
    def is_control_filename(self, filename):
 
285
        """True if filename is the name of a control file in this tree.
 
286
        
 
287
        This is true IF and ONLY IF the filename is part of the meta data
 
288
        that bzr controls in this tree. I.E. a random .bzr directory placed
 
289
        on disk will not be a control file for this tree.
 
290
        """
 
291
        try:
 
292
            self.bzrdir.transport.relpath(self.abspath(filename))
 
293
            return True
 
294
        except errors.PathNotChild:
 
295
            return False
 
296
 
 
297
    @staticmethod
 
298
    def open(path=None, _unsupported=False):
 
299
        """Open an existing working tree at path.
 
300
 
 
301
        """
 
302
        if path is None:
 
303
            path = os.path.getcwdu()
 
304
        control = bzrdir.BzrDir.open(path, _unsupported)
 
305
        return control.open_workingtree(_unsupported)
 
306
        
220
307
    @staticmethod
221
308
    def open_containing(path=None):
222
309
        """Open an existing working tree which has its root about path.
229
316
        If there is one, it is returned, along with the unused portion of path.
230
317
        """
231
318
        if path is None:
232
 
            path = getcwd()
233
 
        else:
234
 
            # sanity check.
235
 
            if path.find('://') != -1:
236
 
                raise NotBranchError(path=path)
237
 
        path = abspath(path)
238
 
        orig_path = path[:]
239
 
        tail = u''
240
 
        while True:
241
 
            try:
242
 
                return WorkingTree(path), tail
243
 
            except NotBranchError:
244
 
                pass
245
 
            if tail:
246
 
                tail = pathjoin(os.path.basename(path), tail)
247
 
            else:
248
 
                tail = os.path.basename(path)
249
 
            lastpath = path
250
 
            path = os.path.dirname(path)
251
 
            if lastpath == path:
252
 
                # reached the root, whatever that may be
253
 
                raise NotBranchError(path=orig_path)
 
319
            path = os.getcwdu()
 
320
        control, relpath = bzrdir.BzrDir.open_containing(path)
 
321
        return control.open_workingtree(), relpath
 
322
 
 
323
    @staticmethod
 
324
    def open_downlevel(path=None):
 
325
        """Open an unsupported working tree.
 
326
 
 
327
        Only intended for advanced situations like upgrading part of a bzrdir.
 
328
        """
 
329
        return WorkingTree.open(path, _unsupported=True)
254
330
 
255
331
    def __iter__(self):
256
332
        """Iterate through file_ids for this tree.
269
345
 
270
346
    def abspath(self, filename):
271
347
        return pathjoin(self.basedir, filename)
 
348
    
 
349
    def basis_tree(self):
 
350
        """Return RevisionTree for the current last revision."""
 
351
        revision_id = self.last_revision()
 
352
        if revision_id is not None:
 
353
            try:
 
354
                xml = self.read_basis_inventory(revision_id)
 
355
                inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
356
                return bzrlib.tree.RevisionTree(self.branch.repository, inv,
 
357
                                                revision_id)
 
358
            except NoSuchFile:
 
359
                pass
 
360
        return self.branch.repository.revision_tree(revision_id)
 
361
 
 
362
    @staticmethod
 
363
    @deprecated_method(zero_eight)
 
364
    def create(branch, directory):
 
365
        """Create a workingtree for branch at directory.
 
366
 
 
367
        If existing_directory already exists it must have a .bzr directory.
 
368
        If it does not exist, it will be created.
 
369
 
 
370
        This returns a new WorkingTree object for the new checkout.
 
371
 
 
372
        TODO FIXME RBC 20060124 when we have checkout formats in place this
 
373
        should accept an optional revisionid to checkout [and reject this if
 
374
        checking out into the same dir as a pre-checkout-aware branch format.]
 
375
 
 
376
        XXX: When BzrDir is present, these should be created through that 
 
377
        interface instead.
 
378
        """
 
379
        warn('delete WorkingTree.create', stacklevel=3)
 
380
        transport = get_transport(directory)
 
381
        if branch.bzrdir.root_transport.base == transport.base:
 
382
            # same dir 
 
383
            return branch.bzrdir.create_workingtree()
 
384
        # different directory, 
 
385
        # create a branch reference
 
386
        # and now a working tree.
 
387
        raise NotImplementedError
 
388
 
 
389
    @staticmethod
 
390
    @deprecated_method(zero_eight)
 
391
    def create_standalone(directory):
 
392
        """Create a checkout and a branch and a repo at directory.
 
393
 
 
394
        Directory must exist and be empty.
 
395
 
 
396
        please use BzrDir.create_standalone_workingtree
 
397
        """
 
398
        return bzrdir.BzrDir.create_standalone_workingtree(directory)
272
399
 
273
400
    def relpath(self, abs):
274
401
        """Return the local path portion from a given absolute path."""
292
419
        ## XXX: badly named; this is not in the store at all
293
420
        return self.abspath(self.id2path(file_id))
294
421
 
 
422
    @needs_read_lock
 
423
    def clone(self, to_bzrdir, revision_id=None, basis=None):
 
424
        """Duplicate this working tree into to_bzr, including all state.
 
425
        
 
426
        Specifically modified files are kept as modified, but
 
427
        ignored and unknown files are discarded.
 
428
 
 
429
        If you want to make a new line of development, see bzrdir.sprout()
 
430
 
 
431
        revision
 
432
            If not None, the cloned tree will have its last revision set to 
 
433
            revision, and and difference between the source trees last revision
 
434
            and this one merged in.
 
435
 
 
436
        basis
 
437
            If not None, a closer copy of a tree which may have some files in
 
438
            common, and which file content should be preferentially copied from.
 
439
        """
 
440
        # assumes the target bzr dir format is compatible.
 
441
        result = self._format.initialize(to_bzrdir)
 
442
        self.copy_content_into(result, revision_id)
 
443
        return result
 
444
 
 
445
    @needs_read_lock
 
446
    def copy_content_into(self, tree, revision_id=None):
 
447
        """Copy the current content and user files of this tree into tree."""
 
448
        if revision_id is None:
 
449
            transform_tree(tree, self)
 
450
        else:
 
451
            # TODO now merge from tree.last_revision to revision
 
452
            transform_tree(tree, self)
 
453
            tree.set_last_revision(revision_id)
 
454
 
295
455
    @needs_write_lock
296
 
    def commit(self, *args, **kw):
 
456
    def commit(self, *args, **kwargs):
297
457
        from bzrlib.commit import Commit
298
 
        Commit().commit(self.branch, *args, **kw)
 
458
        # args for wt.commit start at message from the Commit.commit method,
 
459
        # but with branch a kwarg now, passing in args as is results in the
 
460
        #message being used for the branch
 
461
        args = (DEPRECATED_PARAMETER, ) + args
 
462
        Commit().commit(working_tree=self, *args, **kwargs)
299
463
        self._set_inventory(self.read_working_inventory())
300
464
 
301
465
    def id2abspath(self, file_id):
325
489
        return self._hashcache.get_sha1(path)
326
490
 
327
491
    def is_executable(self, file_id):
328
 
        if os.name == "nt":
 
492
        if not supports_executable():
329
493
            return self._inventory[file_id].executable
330
494
        else:
331
495
            path = self._inventory.id2path(file_id)
370
534
 
371
535
        inv = self.read_working_inventory()
372
536
        for f,file_id in zip(files, ids):
373
 
            if is_control_file(f):
 
537
            if self.is_control_filename(f):
374
538
                raise BzrError("cannot add control file %s" % quotefn(f))
375
539
 
376
540
            fp = splitpath(f)
382
546
 
383
547
            try:
384
548
                kind = file_kind(fullpath)
385
 
            except OSError:
 
549
            except OSError, e:
 
550
                if e.errno == errno.ENOENT:
 
551
                    raise NoSuchFile(fullpath)
386
552
                # maybe something better?
387
553
                raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
388
554
 
419
585
        directory but not yet committed.
420
586
        """
421
587
        try:
422
 
            f = self.branch.control_files.get_utf8('pending-merges')
423
 
        except NoSuchFile:
 
588
            merges_file = self._control_files.get_utf8('pending-merges')
 
589
        except OSError, e:
 
590
            if e.errno != errno.ENOENT:
 
591
                raise
424
592
            return []
425
593
        p = []
426
 
        for l in f.readlines():
 
594
        for l in merges_file.readlines():
427
595
            p.append(l.rstrip('\n'))
428
596
        return p
429
597
 
430
598
    @needs_write_lock
431
599
    def set_pending_merges(self, rev_list):
432
 
        self.branch.control_files.put_utf8('pending-merges', '\n'.join(rev_list))
 
600
        self._control_files.put_utf8('pending-merges', '\n'.join(rev_list))
433
601
 
434
602
    def get_symlink_target(self, file_id):
435
603
        return os.readlink(self.id2abspath(file_id))
442
610
        else:
443
611
            return '?'
444
612
 
445
 
 
446
613
    def list_files(self):
447
614
        """Recursively list all files as (path, class, kind, id).
448
615
 
462
629
                ## TODO: If we find a subdirectory with its own .bzr
463
630
                ## directory, then that is a separate tree and we
464
631
                ## should exclude it.
465
 
                if bzrlib.BZRDIR == f:
 
632
 
 
633
                # the bzrdir for this tree
 
634
                if self.bzrdir.transport.base.endswith(f + '/'):
466
635
                    continue
467
636
 
468
637
                # path within tree
639
808
        These are files in the working directory that are not versioned or
640
809
        control files or ignored.
641
810
        
642
 
        >>> from bzrlib.branch import ScratchBranch
643
 
        >>> b = ScratchBranch(files=['foo', 'foo~'])
644
 
        >>> tree = WorkingTree(b.base, b)
 
811
        >>> from bzrlib.bzrdir import ScratchDir
 
812
        >>> d = ScratchDir(files=['foo', 'foo~'])
 
813
        >>> b = d.open_branch()
 
814
        >>> tree = d.open_workingtree()
645
815
        >>> map(str, tree.unknowns())
646
816
        ['foo']
647
817
        >>> tree.add('foo')
666
836
                yield stem
667
837
 
668
838
    @needs_write_lock
669
 
    def pull(self, source, overwrite=False):
670
 
        from bzrlib.merge import merge_inner
 
839
    def pull(self, source, overwrite=False, stop_revision=None):
671
840
        source.lock_read()
672
841
        try:
673
842
            old_revision_history = self.branch.revision_history()
674
 
            count = self.branch.pull(source, overwrite)
 
843
            basis_tree = self.basis_tree()
 
844
            count = self.branch.pull(source, overwrite, stop_revision)
675
845
            new_revision_history = self.branch.revision_history()
676
846
            if new_revision_history != old_revision_history:
677
847
                if len(old_revision_history):
680
850
                    other_revision = None
681
851
                repository = self.branch.repository
682
852
                merge_inner(self.branch,
683
 
                            self.branch.basis_tree(), 
684
 
                            repository.revision_tree(other_revision))
 
853
                            self.branch.basis_tree(),
 
854
                            basis_tree, 
 
855
                            this_tree=self, 
 
856
                            pb=bzrlib.ui.ui_factory.progress_bar())
 
857
                self.set_last_revision(self.branch.last_revision())
685
858
            return count
686
859
        finally:
687
860
            source.unlock()
780
953
    def kind(self, file_id):
781
954
        return file_kind(self.id2abspath(file_id))
782
955
 
 
956
    @needs_read_lock
 
957
    def last_revision(self):
 
958
        """Return the last revision id of this working tree.
 
959
 
 
960
        In early branch formats this was == the branch last_revision,
 
961
        but that cannot be relied upon - for working tree operations,
 
962
        always use tree.last_revision().
 
963
        """
 
964
        return self.branch.last_revision()
 
965
 
783
966
    def lock_read(self):
784
967
        """See Branch.lock_read, and WorkingTree.unlock."""
785
 
        return self.branch.lock_read()
 
968
        self.branch.lock_read()
 
969
        try:
 
970
            return self._control_files.lock_read()
 
971
        except:
 
972
            self.branch.unlock()
 
973
            raise
786
974
 
787
975
    def lock_write(self):
788
976
        """See Branch.lock_write, and WorkingTree.unlock."""
789
 
        return self.branch.lock_write()
 
977
        self.branch.lock_write()
 
978
        try:
 
979
            return self._control_files.lock_write()
 
980
        except:
 
981
            self.branch.unlock()
 
982
            raise
790
983
 
791
984
    def _basis_inventory_name(self, revision_id):
792
985
        return 'basis-inventory.%s' % revision_id
793
986
 
 
987
    @needs_write_lock
794
988
    def set_last_revision(self, new_revision, old_revision=None):
795
 
        if old_revision is not None:
796
 
            try:
797
 
                path = self._basis_inventory_name(old_revision)
798
 
                path = self.branch.control_files._escape(path)
799
 
                self.branch.control_files._transport.delete(path)
800
 
            except NoSuchFile:
801
 
                pass
 
989
        """Change the last revision in the working tree."""
 
990
        self._remove_old_basis(old_revision)
 
991
        if self._change_last_revision(new_revision):
 
992
            self._cache_basis_inventory(new_revision)
 
993
 
 
994
    def _change_last_revision(self, new_revision):
 
995
        """Template method part of set_last_revision to perform the change."""
 
996
        if new_revision is None:
 
997
            self.branch.set_revision_history([])
 
998
            return False
 
999
        # current format is locked in with the branch
 
1000
        revision_history = self.branch.revision_history()
 
1001
        try:
 
1002
            position = revision_history.index(new_revision)
 
1003
        except ValueError:
 
1004
            raise errors.NoSuchRevision(self.branch, new_revision)
 
1005
        self.branch.set_revision_history(revision_history[:position + 1])
 
1006
        return True
 
1007
 
 
1008
    def _cache_basis_inventory(self, new_revision):
 
1009
        """Cache new_revision as the basis inventory."""
802
1010
        try:
803
1011
            xml = self.branch.repository.get_inventory_xml(new_revision)
804
1012
            path = self._basis_inventory_name(new_revision)
805
 
            self.branch.control_files.put_utf8(path, xml)
 
1013
            self._control_files.put_utf8(path, xml)
806
1014
        except WeaveRevisionNotPresent:
807
1015
            pass
808
1016
 
 
1017
    def _remove_old_basis(self, old_revision):
 
1018
        """Remove the old basis inventory 'old_revision'."""
 
1019
        if old_revision is not None:
 
1020
            try:
 
1021
                path = self._basis_inventory_name(old_revision)
 
1022
                path = self._control_files._escape(path)
 
1023
                self._control_files._transport.delete(path)
 
1024
            except NoSuchFile:
 
1025
                pass
 
1026
 
809
1027
    def read_basis_inventory(self, revision_id):
810
1028
        """Read the cached basis inventory."""
811
1029
        path = self._basis_inventory_name(revision_id)
812
 
        return self.branch.control_files.get_utf8(path).read()
 
1030
        return self._control_files.get_utf8(path).read()
813
1031
        
814
1032
    @needs_read_lock
815
1033
    def read_working_inventory(self):
816
1034
        """Read the working inventory."""
817
1035
        # ElementTree does its own conversion from UTF-8, so open in
818
1036
        # binary.
819
 
        f = self.branch.control_files.get('inventory')
820
 
        return bzrlib.xml5.serializer_v5.read_inventory(f)
 
1037
        result = bzrlib.xml5.serializer_v5.read_inventory(
 
1038
            self._control_files.get('inventory'))
 
1039
        self._set_inventory(result)
 
1040
        return result
821
1041
 
822
1042
    @needs_write_lock
823
1043
    def remove(self, files, verbose=False):
861
1081
        self._write_inventory(inv)
862
1082
 
863
1083
    @needs_write_lock
864
 
    def revert(self, filenames, old_tree=None, backups=True):
865
 
        from bzrlib.merge import merge_inner
 
1084
    def revert(self, filenames, old_tree=None, backups=True, 
 
1085
               pb=DummyProgress()):
 
1086
        from transform import revert
866
1087
        if old_tree is None:
867
 
            old_tree = self.branch.basis_tree()
868
 
        merge_inner(self.branch, old_tree,
869
 
                    self, ignore_zero=True,
870
 
                    backup_files=backups, 
871
 
                    interesting_files=filenames)
 
1088
            old_tree = self.basis_tree()
 
1089
        revert(self, old_tree, filenames, backups, pb)
872
1090
        if not len(filenames):
873
1091
            self.set_pending_merges([])
874
1092
 
905
1123
        inv._byid[inv.root.file_id] = inv.root
906
1124
        for fid in inv:
907
1125
            entry = inv[fid]
908
 
            if entry.parent_id in (None, orig_root_id):
 
1126
            if entry.parent_id == orig_root_id:
909
1127
                entry.parent_id = inv.root.file_id
910
1128
        self._write_inventory(inv)
911
1129
 
923
1141
        # of a nasty hack; probably it's better to have a transaction object,
924
1142
        # which can do some finalization when it's either successfully or
925
1143
        # unsuccessfully completed.  (Denys's original patch did that.)
926
 
        if self._hashcache.needs_write and self.branch.control_files._lock_count==1:
 
1144
        # RBC 20060206 hookinhg into transaction will couple lock and transaction
 
1145
        # wrongly. Hookinh into unllock on the control files object is fine though.
 
1146
        
 
1147
        # TODO: split this per format so there is no ugly if block
 
1148
        if self._hashcache.needs_write and (
 
1149
            # dedicated lock files
 
1150
            self._control_files._lock_count==1 or 
 
1151
            # shared lock files
 
1152
            (self._control_files is self.branch.control_files and 
 
1153
             self._control_files._lock_count==3)):
927
1154
            self._hashcache.write()
928
 
        return self.branch.unlock()
 
1155
        # reverse order of locking.
 
1156
        result = self._control_files.unlock()
 
1157
        try:
 
1158
            self.branch.unlock()
 
1159
        finally:
 
1160
            return result
 
1161
 
 
1162
    @needs_write_lock
 
1163
    def update(self):
 
1164
        self.branch.lock_read()
 
1165
        try:
 
1166
            if self.last_revision() == self.branch.last_revision():
 
1167
                return
 
1168
            basis = self.basis_tree()
 
1169
            to_tree = self.branch.basis_tree()
 
1170
            result = merge_inner(self.branch,
 
1171
                                 to_tree,
 
1172
                                 basis,
 
1173
                                 this_tree=self)
 
1174
            self.set_last_revision(self.branch.last_revision())
 
1175
            return result
 
1176
        finally:
 
1177
            self.branch.unlock()
929
1178
 
930
1179
    @needs_write_lock
931
1180
    def _write_inventory(self, inv):
932
1181
        """Write inventory as the current inventory."""
933
 
        from cStringIO import StringIO
934
 
        from bzrlib.atomicfile import AtomicFile
935
1182
        sio = StringIO()
936
1183
        bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
937
1184
        sio.seek(0)
938
 
        f = AtomicFile(self.branch.control_files.controlfilename('inventory'))
939
 
        try:
940
 
            pumpfile(sio, f)
941
 
            f.commit()
942
 
        finally:
943
 
            f.close()
 
1185
        self._control_files.put('inventory', sio)
944
1186
        self._set_inventory(inv)
945
1187
        mutter('wrote working inventory')
946
 
            
 
1188
 
 
1189
 
 
1190
class WorkingTree3(WorkingTree):
 
1191
    """This is the Format 3 working tree.
 
1192
 
 
1193
    This differs from the base WorkingTree by:
 
1194
     - having its own file lock
 
1195
     - having its own last-revision property.
 
1196
    """
 
1197
 
 
1198
    @needs_read_lock
 
1199
    def last_revision(self):
 
1200
        """See WorkingTree.last_revision."""
 
1201
        try:
 
1202
            return self._control_files.get_utf8('last-revision').read()
 
1203
        except NoSuchFile:
 
1204
            return None
 
1205
 
 
1206
    def _change_last_revision(self, revision_id):
 
1207
        """See WorkingTree._change_last_revision."""
 
1208
        if revision_id is None or revision_id == NULL_REVISION:
 
1209
            try:
 
1210
                self._control_files._transport.delete('last-revision')
 
1211
            except errors.NoSuchFile:
 
1212
                pass
 
1213
            return False
 
1214
        else:
 
1215
            try:
 
1216
                self.branch.revision_history().index(revision_id)
 
1217
            except ValueError:
 
1218
                raise errors.NoSuchRevision(self.branch, revision_id)
 
1219
            self._control_files.put_utf8('last-revision', revision_id)
 
1220
            return True
 
1221
 
947
1222
 
948
1223
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
949
1224
def get_conflicted_stem(path):
950
1225
    for suffix in CONFLICT_SUFFIXES:
951
1226
        if path.endswith(suffix):
952
1227
            return path[:-len(suffix)]
 
1228
 
 
1229
@deprecated_function(zero_eight)
 
1230
def is_control_file(filename):
 
1231
    """See WorkingTree.is_control_filename(filename)."""
 
1232
    ## FIXME: better check
 
1233
    filename = normpath(filename)
 
1234
    while filename != '':
 
1235
        head, tail = os.path.split(filename)
 
1236
        ## mutter('check %r for control file' % ((head, tail),))
 
1237
        if tail == '.bzr':
 
1238
            return True
 
1239
        if filename == head:
 
1240
            break
 
1241
        filename = head
 
1242
    return False
 
1243
 
 
1244
 
 
1245
class WorkingTreeFormat(object):
 
1246
    """An encapsulation of the initialization and open routines for a format.
 
1247
 
 
1248
    Formats provide three things:
 
1249
     * An initialization routine,
 
1250
     * a format string,
 
1251
     * an open routine.
 
1252
 
 
1253
    Formats are placed in an dict by their format string for reference 
 
1254
    during workingtree opening. Its not required that these be instances, they
 
1255
    can be classes themselves with class methods - it simply depends on 
 
1256
    whether state is needed for a given format or not.
 
1257
 
 
1258
    Once a format is deprecated, just deprecate the initialize and open
 
1259
    methods on the format class. Do not deprecate the object, as the 
 
1260
    object will be created every time regardless.
 
1261
    """
 
1262
 
 
1263
    _default_format = None
 
1264
    """The default format used for new trees."""
 
1265
 
 
1266
    _formats = {}
 
1267
    """The known formats."""
 
1268
 
 
1269
    @classmethod
 
1270
    def find_format(klass, a_bzrdir):
 
1271
        """Return the format for the working tree object in a_bzrdir."""
 
1272
        try:
 
1273
            transport = a_bzrdir.get_workingtree_transport(None)
 
1274
            format_string = transport.get("format").read()
 
1275
            return klass._formats[format_string]
 
1276
        except NoSuchFile:
 
1277
            raise errors.NoWorkingTree(base=transport.base)
 
1278
        except KeyError:
 
1279
            raise errors.UnknownFormatError(format_string)
 
1280
 
 
1281
    @classmethod
 
1282
    def get_default_format(klass):
 
1283
        """Return the current default format."""
 
1284
        return klass._default_format
 
1285
 
 
1286
    def get_format_string(self):
 
1287
        """Return the ASCII format string that identifies this format."""
 
1288
        raise NotImplementedError(self.get_format_string)
 
1289
 
 
1290
    def is_supported(self):
 
1291
        """Is this format supported?
 
1292
 
 
1293
        Supported formats can be initialized and opened.
 
1294
        Unsupported formats may not support initialization or committing or 
 
1295
        some other features depending on the reason for not being supported.
 
1296
        """
 
1297
        return True
 
1298
 
 
1299
    @classmethod
 
1300
    def register_format(klass, format):
 
1301
        klass._formats[format.get_format_string()] = format
 
1302
 
 
1303
    @classmethod
 
1304
    def set_default_format(klass, format):
 
1305
        klass._default_format = format
 
1306
 
 
1307
    @classmethod
 
1308
    def unregister_format(klass, format):
 
1309
        assert klass._formats[format.get_format_string()] is format
 
1310
        del klass._formats[format.get_format_string()]
 
1311
 
 
1312
 
 
1313
 
 
1314
class WorkingTreeFormat2(WorkingTreeFormat):
 
1315
    """The second working tree format. 
 
1316
 
 
1317
    This format modified the hash cache from the format 1 hash cache.
 
1318
    """
 
1319
 
 
1320
    def initialize(self, a_bzrdir, revision_id=None):
 
1321
        """See WorkingTreeFormat.initialize()."""
 
1322
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1323
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1324
        branch = a_bzrdir.open_branch()
 
1325
        if revision_id is not None:
 
1326
            branch.lock_write()
 
1327
            try:
 
1328
                revision_history = branch.revision_history()
 
1329
                try:
 
1330
                    position = revision_history.index(revision_id)
 
1331
                except ValueError:
 
1332
                    raise errors.NoSuchRevision(branch, revision_id)
 
1333
                branch.set_revision_history(revision_history[:position + 1])
 
1334
            finally:
 
1335
                branch.unlock()
 
1336
        revision = branch.last_revision()
 
1337
        inv = Inventory() 
 
1338
        wt = WorkingTree(a_bzrdir.root_transport.base,
 
1339
                         branch,
 
1340
                         inv,
 
1341
                         _internal=True,
 
1342
                         _format=self,
 
1343
                         _bzrdir=a_bzrdir)
 
1344
        wt._write_inventory(inv)
 
1345
        wt.set_root_id(inv.root.file_id)
 
1346
        wt.set_last_revision(revision)
 
1347
        wt.set_pending_merges([])
 
1348
        build_tree(wt.basis_tree(), wt)
 
1349
        return wt
 
1350
 
 
1351
    def __init__(self):
 
1352
        super(WorkingTreeFormat2, self).__init__()
 
1353
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
 
1354
 
 
1355
    def open(self, a_bzrdir, _found=False):
 
1356
        """Return the WorkingTree object for a_bzrdir
 
1357
 
 
1358
        _found is a private parameter, do not use it. It is used to indicate
 
1359
               if format probing has already been done.
 
1360
        """
 
1361
        if not _found:
 
1362
            # we are being called directly and must probe.
 
1363
            raise NotImplementedError
 
1364
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1365
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1366
        return WorkingTree(a_bzrdir.root_transport.base,
 
1367
                           _internal=True,
 
1368
                           _format=self,
 
1369
                           _bzrdir=a_bzrdir)
 
1370
 
 
1371
 
 
1372
class WorkingTreeFormat3(WorkingTreeFormat):
 
1373
    """The second working tree format updated to record a format marker.
 
1374
 
 
1375
    This format modified the hash cache from the format 1 hash cache.
 
1376
    """
 
1377
 
 
1378
    def get_format_string(self):
 
1379
        """See WorkingTreeFormat.get_format_string()."""
 
1380
        return "Bazaar-NG Working Tree format 3"
 
1381
 
 
1382
    def initialize(self, a_bzrdir, revision_id=None):
 
1383
        """See WorkingTreeFormat.initialize().
 
1384
        
 
1385
        revision_id allows creating a working tree at a differnet
 
1386
        revision than the branch is at.
 
1387
        """
 
1388
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1389
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1390
        transport = a_bzrdir.get_workingtree_transport(self)
 
1391
        control_files = LockableFiles(transport, 'lock')
 
1392
        control_files.put_utf8('format', self.get_format_string())
 
1393
        branch = a_bzrdir.open_branch()
 
1394
        if revision_id is None:
 
1395
            revision_id = branch.last_revision()
 
1396
        inv = Inventory() 
 
1397
        wt = WorkingTree3(a_bzrdir.root_transport.base,
 
1398
                         branch,
 
1399
                         inv,
 
1400
                         _internal=True,
 
1401
                         _format=self,
 
1402
                         _bzrdir=a_bzrdir)
 
1403
        wt._write_inventory(inv)
 
1404
        wt.set_root_id(inv.root.file_id)
 
1405
        wt.set_last_revision(revision_id)
 
1406
        wt.set_pending_merges([])
 
1407
        build_tree(wt.basis_tree(), wt)
 
1408
        return wt
 
1409
 
 
1410
    def __init__(self):
 
1411
        super(WorkingTreeFormat3, self).__init__()
 
1412
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1413
 
 
1414
    def open(self, a_bzrdir, _found=False):
 
1415
        """Return the WorkingTree object for a_bzrdir
 
1416
 
 
1417
        _found is a private parameter, do not use it. It is used to indicate
 
1418
               if format probing has already been done.
 
1419
        """
 
1420
        if not _found:
 
1421
            # we are being called directly and must probe.
 
1422
            raise NotImplementedError
 
1423
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1424
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1425
        return WorkingTree3(a_bzrdir.root_transport.base,
 
1426
                           _internal=True,
 
1427
                           _format=self,
 
1428
                           _bzrdir=a_bzrdir)
 
1429
 
 
1430
    def __str__(self):
 
1431
        return self.get_format_string()
 
1432
 
 
1433
 
 
1434
# formats which have no format string are not discoverable
 
1435
# and not independently creatable, so are not registered.
 
1436
__default_format = WorkingTreeFormat3()
 
1437
WorkingTreeFormat.register_format(__default_format)
 
1438
WorkingTreeFormat.set_default_format(__default_format)
 
1439
_legacy_formats = [WorkingTreeFormat2(),
 
1440
                   ]
 
1441
 
 
1442
 
 
1443
class WorkingTreeTestProviderAdapter(object):
 
1444
    """A tool to generate a suite testing multiple workingtree formats at once.
 
1445
 
 
1446
    This is done by copying the test once for each transport and injecting
 
1447
    the transport_server, transport_readonly_server, and workingtree_format
 
1448
    classes into each copy. Each copy is also given a new id() to make it
 
1449
    easy to identify.
 
1450
    """
 
1451
 
 
1452
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1453
        self._transport_server = transport_server
 
1454
        self._transport_readonly_server = transport_readonly_server
 
1455
        self._formats = formats
 
1456
    
 
1457
    def adapt(self, test):
 
1458
        from bzrlib.tests import TestSuite
 
1459
        result = TestSuite()
 
1460
        for workingtree_format, bzrdir_format in self._formats:
 
1461
            new_test = deepcopy(test)
 
1462
            new_test.transport_server = self._transport_server
 
1463
            new_test.transport_readonly_server = self._transport_readonly_server
 
1464
            new_test.bzrdir_format = bzrdir_format
 
1465
            new_test.workingtree_format = workingtree_format
 
1466
            def make_new_test_id():
 
1467
                new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
 
1468
                return lambda: new_id
 
1469
            new_test.id = make_new_test_id()
 
1470
            result.addTest(new_test)
 
1471
        return result