← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-06-20 03:50:35 UTC
  • mfrom: (1740.5.9 bzr.mbp.traceback)
  • Revision ID: pqm@pqm.ubuntu.com-20060620035035-a9a7dc096fed5060
(mbp) show traceback on stderr on unexpected errors

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
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
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
 
# TODO: Don't allow WorkingTrees to be constructed for remote branches if 
33
 
# they don't work.
34
 
 
35
 
# FIXME: I don't know if writing out the cache from the destructor is really a
36
 
# good idea, because destructors are considered poor taste in Python, and it's
37
 
# not predictable when it will be written out.
 
32
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
 
33
CONFLICT_HEADER_1 = "BZR conflict list format 1"
38
34
 
39
35
# TODO: Give the workingtree sole responsibility for the working inventory;
40
36
# remove the variable and references to it from the branch.  This may require
41
37
# updating the commit code so as to update the inventory within the working
42
38
# copy, and making sure there's only one WorkingTree for any directory on disk.
43
 
# At the momenthey may alias the inventory and have old copies of it in memory.
 
39
# At the moment they may alias the inventory and have old copies of it in
 
40
# memory.  (Now done? -- mbp 20060309)
44
41
 
 
42
from binascii import hexlify
 
43
import collections
45
44
from copy import deepcopy
 
45
from cStringIO import StringIO
 
46
import errno
 
47
import fnmatch
46
48
import os
 
49
import re
47
50
import stat
48
 
import fnmatch
49
 
 
 
51
from time import time
 
52
 
 
53
from bzrlib.atomicfile import AtomicFile
50
54
from bzrlib.branch import (Branch,
51
 
                           is_control_file,
52
 
                           needs_read_lock,
53
 
                           needs_write_lock,
54
55
                           quotefn)
 
56
from bzrlib.conflicts import Conflict, ConflictList, CONFLICT_SUFFIXES
 
57
import bzrlib.bzrdir as bzrdir
 
58
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
59
import bzrlib.errors as errors
55
60
from bzrlib.errors import (BzrCheckError,
56
61
                           BzrError,
57
 
                           DivergedBranches,
 
62
                           ConflictFormatError,
58
63
                           WeaveRevisionNotPresent,
59
64
                           NotBranchError,
60
 
                           NotVersionedError)
61
 
from bzrlib.inventory import InventoryEntry
62
 
from bzrlib.osutils import (appendpath,
 
65
                           NoSuchFile,
 
66
                           NotVersionedError,
 
67
                           MergeModifiedFormatError,
 
68
                           UnsupportedOperation,
 
69
                           )
 
70
from bzrlib.inventory import InventoryEntry, Inventory
 
71
from bzrlib.lockable_files import LockableFiles, TransportLock
 
72
from bzrlib.lockdir import LockDir
 
73
from bzrlib.merge import merge_inner, transform_tree
 
74
from bzrlib.osutils import (
 
75
                            abspath,
63
76
                            compact_date,
64
77
                            file_kind,
65
78
                            isdir,
66
79
                            getcwd,
67
80
                            pathjoin,
68
81
                            pumpfile,
 
82
                            safe_unicode,
69
83
                            splitpath,
70
 
                            rand_bytes,
71
 
                            abspath,
 
84
                            rand_chars,
72
85
                            normpath,
73
86
                            realpath,
74
87
                            relpath,
75
 
                            rename)
 
88
                            rename,
 
89
                            supports_executable,
 
90
                            )
 
91
from bzrlib.progress import DummyProgress, ProgressPhase
 
92
from bzrlib.revision import NULL_REVISION
 
93
from bzrlib.rio import RioReader, rio_file, Stanza
 
94
from bzrlib.symbol_versioning import *
76
95
from bzrlib.textui import show_status
77
96
import bzrlib.tree
78
 
from bzrlib.trace import mutter
 
97
from bzrlib.transform import build_tree
 
98
from bzrlib.trace import mutter, note
 
99
from bzrlib.transport import get_transport
 
100
from bzrlib.transport.local import LocalTransport
 
101
import bzrlib.urlutils as urlutils
 
102
import bzrlib.ui
79
103
import bzrlib.xml5
80
104
 
81
105
 
 
106
# the regex here does the following:
 
107
# 1) remove any weird characters; we don't escape them but rather
 
108
# just pull them out
 
109
 # 2) match leading '.'s to make it not hidden
 
110
_gen_file_id_re = re.compile(r'[^\w.]|(^\.*)')
 
111
_gen_id_suffix = None
 
112
_gen_id_serial = 0
 
113
 
 
114
 
 
115
def _next_id_suffix():
 
116
    """Create a new file id suffix that is reasonably unique.
 
117
    
 
118
    On the first call we combine the current time with 64 bits of randomness
 
119
    to give a highly probably globally unique number. Then each call in the same
 
120
    process adds 1 to a serial number we append to that unique value.
 
121
    """
 
122
    # XXX TODO: change bzrlib.add.smart_add to call workingtree.add() rather 
 
123
    # than having to move the id randomness out of the inner loop like this.
 
124
    # XXX TODO: for the global randomness this uses we should add the thread-id
 
125
    # before the serial #.
 
126
    global _gen_id_suffix, _gen_id_serial
 
127
    if _gen_id_suffix is None:
 
128
        _gen_id_suffix = "-%s-%s-" % (compact_date(time()), rand_chars(16))
 
129
    _gen_id_serial += 1
 
130
    return _gen_id_suffix + str(_gen_id_serial)
 
131
 
 
132
 
82
133
def gen_file_id(name):
83
 
    """Return new file id.
84
 
 
85
 
    This should probably generate proper UUIDs, but for the moment we
86
 
    cope with just randomness because running uuidgen every time is
87
 
    slow."""
88
 
    import re
89
 
    from binascii import hexlify
90
 
    from time import time
91
 
 
92
 
    # get last component
93
 
    idx = name.rfind('/')
94
 
    if idx != -1:
95
 
        name = name[idx+1 : ]
96
 
    idx = name.rfind('\\')
97
 
    if idx != -1:
98
 
        name = name[idx+1 : ]
99
 
 
100
 
    # make it not a hidden file
101
 
    name = name.lstrip('.')
102
 
 
103
 
    # remove any wierd characters; we don't escape them but rather
104
 
    # just pull them out
105
 
    name = re.sub(r'[^\w.]', '', name)
106
 
 
107
 
    s = hexlify(rand_bytes(8))
108
 
    return '-'.join((name, compact_date(time()), s))
 
134
    """Return new file id for the basename 'name'.
 
135
 
 
136
    The uniqueness is supplied from _next_id_suffix.
 
137
    """
 
138
    # XXX TODO: squash the filename to lowercase.
 
139
    # XXX TODO: truncate the filename to something like 20 or 30 chars.
 
140
    # XXX TODO: consider what to do with ids that look like illegal filepaths
 
141
    # on platforms we support.
 
142
    return _gen_file_id_re.sub('', name) + _next_id_suffix()
109
143
 
110
144
 
111
145
def gen_root_id():
114
148
 
115
149
 
116
150
class TreeEntry(object):
117
 
    """An entry that implements the minium interface used by commands.
 
151
    """An entry that implements the minimum interface used by commands.
118
152
 
119
153
    This needs further inspection, it may be better to have 
120
154
    InventoryEntries without ids - though that seems wrong. For now,
178
212
    not listed in the Inventory and vice versa.
179
213
    """
180
214
 
181
 
    def __init__(self, basedir=u'.', branch=None):
 
215
    def __init__(self, basedir='.',
 
216
                 branch=DEPRECATED_PARAMETER,
 
217
                 _inventory=None,
 
218
                 _control_files=None,
 
219
                 _internal=False,
 
220
                 _format=None,
 
221
                 _bzrdir=None):
182
222
        """Construct a WorkingTree for basedir.
183
223
 
184
224
        If the branch is not supplied, it is opened automatically.
186
226
        (branch.base is not cross checked, because for remote branches that
187
227
        would be meaningless).
188
228
        """
 
229
        self._format = _format
 
230
        self.bzrdir = _bzrdir
 
231
        if not _internal:
 
232
            # not created via open etc.
 
233
            warn("WorkingTree() is deprecated as of bzr version 0.8. "
 
234
                 "Please use bzrdir.open_workingtree or WorkingTree.open().",
 
235
                 DeprecationWarning,
 
236
                 stacklevel=2)
 
237
            wt = WorkingTree.open(basedir)
 
238
            self._branch = wt.branch
 
239
            self.basedir = wt.basedir
 
240
            self._control_files = wt._control_files
 
241
            self._hashcache = wt._hashcache
 
242
            self._set_inventory(wt._inventory)
 
243
            self._format = wt._format
 
244
            self.bzrdir = wt.bzrdir
189
245
        from bzrlib.hashcache import HashCache
190
246
        from bzrlib.trace import note, mutter
191
247
        assert isinstance(basedir, basestring), \
192
248
            "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
 
249
        basedir = safe_unicode(basedir)
 
250
        mutter("opening working tree %r", basedir)
 
251
        if deprecated_passed(branch):
 
252
            if not _internal:
 
253
                warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
 
254
                     " Please use bzrdir.open_workingtree() or"
 
255
                     " WorkingTree.open().",
 
256
                     DeprecationWarning,
 
257
                     stacklevel=2
 
258
                     )
 
259
            self._branch = branch
 
260
        else:
 
261
            self._branch = self.bzrdir.open_branch()
 
262
        assert isinstance(self.branch, Branch), \
 
263
            "branch %r is not a Branch" % self.branch
198
264
        self.basedir = realpath(basedir)
199
 
 
 
265
        # if branch is at our basedir and is a format 6 or less
 
266
        if isinstance(self._format, WorkingTreeFormat2):
 
267
            # share control object
 
268
            self._control_files = self.branch.control_files
 
269
        else:
 
270
            # only ready for format 3
 
271
            assert isinstance(self._format, WorkingTreeFormat3)
 
272
            assert isinstance(_control_files, LockableFiles), \
 
273
                    "_control_files must be a LockableFiles, not %r" \
 
274
                    % _control_files
 
275
            self._control_files = _control_files
200
276
        # update the whole cache up front and write to disk if anything changed;
201
277
        # in the future we might want to do this more selectively
202
278
        # two possible ways offer themselves : in self._unlock, write the cache
203
279
        # if needed, or, when the cache sees a change, append it to the hash
204
280
        # cache file, and have the parser take the most recent entry for a
205
281
        # given path only.
206
 
        hc = self._hashcache = HashCache(basedir)
 
282
        cache_filename = self.bzrdir.get_workingtree_transport(None).local_abspath('stat-cache')
 
283
        hc = self._hashcache = HashCache(basedir, cache_filename, self._control_files._file_mode)
207
284
        hc.read()
208
 
        hc.scan()
 
285
        # is this scan needed ? it makes things kinda slow.
 
286
        #hc.scan()
209
287
 
210
288
        if hc.needs_write:
211
289
            mutter("write hc")
212
290
            hc.write()
213
291
 
214
 
        self._set_inventory(self.read_working_inventory())
 
292
        if _inventory is None:
 
293
            self._set_inventory(self.read_working_inventory())
 
294
        else:
 
295
            self._set_inventory(_inventory)
 
296
 
 
297
    branch = property(
 
298
        fget=lambda self: self._branch,
 
299
        doc="""The branch this WorkingTree is connected to.
 
300
 
 
301
            This cannot be set - it is reflective of the actual disk structure
 
302
            the working tree has been constructed from.
 
303
            """)
 
304
 
 
305
    def break_lock(self):
 
306
        """Break a lock if one is present from another instance.
 
307
 
 
308
        Uses the ui factory to ask for confirmation if the lock may be from
 
309
        an active process.
 
310
 
 
311
        This will probe the repository for its lock as well.
 
312
        """
 
313
        self._control_files.break_lock()
 
314
        self.branch.break_lock()
215
315
 
216
316
    def _set_inventory(self, inv):
217
317
        self._inventory = inv
218
318
        self.path2id = self._inventory.path2id
219
319
 
 
320
    def is_control_filename(self, filename):
 
321
        """True if filename is the name of a control file in this tree.
 
322
        
 
323
        :param filename: A filename within the tree. This is a relative path
 
324
        from the root of this tree.
 
325
 
 
326
        This is true IF and ONLY IF the filename is part of the meta data
 
327
        that bzr controls in this tree. I.E. a random .bzr directory placed
 
328
        on disk will not be a control file for this tree.
 
329
        """
 
330
        return self.bzrdir.is_control_filename(filename)
 
331
 
 
332
    @staticmethod
 
333
    def open(path=None, _unsupported=False):
 
334
        """Open an existing working tree at path.
 
335
 
 
336
        """
 
337
        if path is None:
 
338
            path = os.path.getcwdu()
 
339
        control = bzrdir.BzrDir.open(path, _unsupported)
 
340
        return control.open_workingtree(_unsupported)
 
341
        
220
342
    @staticmethod
221
343
    def open_containing(path=None):
222
344
        """Open an existing working tree which has its root about path.
227
349
        run into /.  If there isn't one, raises NotBranchError.
228
350
        TODO: give this a new exception.
229
351
        If there is one, it is returned, along with the unused portion of path.
 
352
 
 
353
        :return: The WorkingTree that contains 'path', and the rest of path
230
354
        """
231
355
        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
 
        tail = u''
239
 
        while True:
240
 
            try:
241
 
                return WorkingTree(path), tail
242
 
            except NotBranchError:
243
 
                pass
244
 
            if tail:
245
 
                tail = pathjoin(os.path.basename(path), tail)
246
 
            else:
247
 
                tail = os.path.basename(path)
248
 
            lastpath = path
249
 
            path = os.path.dirname(path)
250
 
            if lastpath == path:
251
 
                # reached the root, whatever that may be
252
 
                raise NotBranchError(path=path)
 
356
            path = os.getcwdu()
 
357
        control, relpath = bzrdir.BzrDir.open_containing(path)
 
358
 
 
359
        return control.open_workingtree(), relpath
 
360
 
 
361
    @staticmethod
 
362
    def open_downlevel(path=None):
 
363
        """Open an unsupported working tree.
 
364
 
 
365
        Only intended for advanced situations like upgrading part of a bzrdir.
 
366
        """
 
367
        return WorkingTree.open(path, _unsupported=True)
253
368
 
254
369
    def __iter__(self):
255
370
        """Iterate through file_ids for this tree.
268
383
 
269
384
    def abspath(self, filename):
270
385
        return pathjoin(self.basedir, filename)
271
 
 
272
 
    def relpath(self, abs):
273
 
        """Return the local path portion from a given absolute path."""
274
 
        return relpath(self.basedir, abs)
 
386
    
 
387
    def basis_tree(self):
 
388
        """Return RevisionTree for the current last revision."""
 
389
        revision_id = self.last_revision()
 
390
        if revision_id is not None:
 
391
            try:
 
392
                xml = self.read_basis_inventory()
 
393
                inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
394
            except NoSuchFile:
 
395
                inv = None
 
396
            if inv is not None and inv.revision_id == revision_id:
 
397
                return bzrlib.tree.RevisionTree(self.branch.repository, inv,
 
398
                                                revision_id)
 
399
        # FIXME? RBC 20060403 should we cache the inventory here ?
 
400
        return self.branch.repository.revision_tree(revision_id)
 
401
 
 
402
    @staticmethod
 
403
    @deprecated_method(zero_eight)
 
404
    def create(branch, directory):
 
405
        """Create a workingtree for branch at directory.
 
406
 
 
407
        If existing_directory already exists it must have a .bzr directory.
 
408
        If it does not exist, it will be created.
 
409
 
 
410
        This returns a new WorkingTree object for the new checkout.
 
411
 
 
412
        TODO FIXME RBC 20060124 when we have checkout formats in place this
 
413
        should accept an optional revisionid to checkout [and reject this if
 
414
        checking out into the same dir as a pre-checkout-aware branch format.]
 
415
 
 
416
        XXX: When BzrDir is present, these should be created through that 
 
417
        interface instead.
 
418
        """
 
419
        warn('delete WorkingTree.create', stacklevel=3)
 
420
        transport = get_transport(directory)
 
421
        if branch.bzrdir.root_transport.base == transport.base:
 
422
            # same dir 
 
423
            return branch.bzrdir.create_workingtree()
 
424
        # different directory, 
 
425
        # create a branch reference
 
426
        # and now a working tree.
 
427
        raise NotImplementedError
 
428
 
 
429
    @staticmethod
 
430
    @deprecated_method(zero_eight)
 
431
    def create_standalone(directory):
 
432
        """Create a checkout and a branch and a repo at directory.
 
433
 
 
434
        Directory must exist and be empty.
 
435
 
 
436
        please use BzrDir.create_standalone_workingtree
 
437
        """
 
438
        return bzrdir.BzrDir.create_standalone_workingtree(directory)
 
439
 
 
440
    def relpath(self, path):
 
441
        """Return the local path portion from a given path.
 
442
        
 
443
        The path may be absolute or relative. If its a relative path it is 
 
444
        interpreted relative to the python current working directory.
 
445
        """
 
446
        return relpath(self.basedir, path)
275
447
 
276
448
    def has_filename(self, filename):
277
449
        return bzrlib.osutils.lexists(self.abspath(filename))
282
454
    def get_file_byname(self, filename):
283
455
        return file(self.abspath(filename), 'rb')
284
456
 
 
457
    def get_parent_ids(self):
 
458
        """See Tree.get_parent_ids.
 
459
        
 
460
        This implementation reads the pending merges list and last_revision
 
461
        value and uses that to decide what the parents list should be.
 
462
        """
 
463
        last_rev = self.last_revision()
 
464
        if last_rev is None:
 
465
            parents = []
 
466
        else:
 
467
            parents = [last_rev]
 
468
        other_parents = self.pending_merges()
 
469
        return parents + other_parents
 
470
 
285
471
    def get_root_id(self):
286
472
        """Return the id of this trees root"""
287
473
        inv = self.read_working_inventory()
291
477
        ## XXX: badly named; this is not in the store at all
292
478
        return self.abspath(self.id2path(file_id))
293
479
 
 
480
    @needs_read_lock
 
481
    def clone(self, to_bzrdir, revision_id=None, basis=None):
 
482
        """Duplicate this working tree into to_bzr, including all state.
 
483
        
 
484
        Specifically modified files are kept as modified, but
 
485
        ignored and unknown files are discarded.
 
486
 
 
487
        If you want to make a new line of development, see bzrdir.sprout()
 
488
 
 
489
        revision
 
490
            If not None, the cloned tree will have its last revision set to 
 
491
            revision, and and difference between the source trees last revision
 
492
            and this one merged in.
 
493
 
 
494
        basis
 
495
            If not None, a closer copy of a tree which may have some files in
 
496
            common, and which file content should be preferentially copied from.
 
497
        """
 
498
        # assumes the target bzr dir format is compatible.
 
499
        result = self._format.initialize(to_bzrdir)
 
500
        self.copy_content_into(result, revision_id)
 
501
        return result
 
502
 
 
503
    @needs_read_lock
 
504
    def copy_content_into(self, tree, revision_id=None):
 
505
        """Copy the current content and user files of this tree into tree."""
 
506
        if revision_id is None:
 
507
            transform_tree(tree, self)
 
508
        else:
 
509
            # TODO now merge from tree.last_revision to revision
 
510
            transform_tree(tree, self)
 
511
            tree.set_last_revision(revision_id)
 
512
 
294
513
    @needs_write_lock
295
 
    def commit(self, *args, **kw):
 
514
    def commit(self, message=None, revprops=None, *args, **kwargs):
 
515
        # avoid circular imports
296
516
        from bzrlib.commit import Commit
297
 
        Commit().commit(self.branch, *args, **kw)
 
517
        if revprops is None:
 
518
            revprops = {}
 
519
        if not 'branch-nick' in revprops:
 
520
            revprops['branch-nick'] = self.branch.nick
 
521
        # args for wt.commit start at message from the Commit.commit method,
 
522
        # but with branch a kwarg now, passing in args as is results in the
 
523
        #message being used for the branch
 
524
        args = (DEPRECATED_PARAMETER, message, ) + args
 
525
        committed_id = Commit().commit( working_tree=self, revprops=revprops,
 
526
            *args, **kwargs)
298
527
        self._set_inventory(self.read_working_inventory())
 
528
        return committed_id
299
529
 
300
530
    def id2abspath(self, file_id):
301
531
        return self.abspath(self.id2path(file_id))
319
549
        return os.path.getsize(self.id2abspath(file_id))
320
550
 
321
551
    @needs_read_lock
322
 
    def get_file_sha1(self, file_id):
323
 
        path = self._inventory.id2path(file_id)
 
552
    def get_file_sha1(self, file_id, path=None):
 
553
        if not path:
 
554
            path = self._inventory.id2path(file_id)
324
555
        return self._hashcache.get_sha1(path)
325
556
 
326
 
    def is_executable(self, file_id):
327
 
        if os.name == "nt":
 
557
    def get_file_mtime(self, file_id, path=None):
 
558
        if not path:
 
559
            path = self._inventory.id2path(file_id)
 
560
        return os.lstat(self.abspath(path)).st_mtime
 
561
 
 
562
    if not supports_executable():
 
563
        def is_executable(self, file_id, path=None):
328
564
            return self._inventory[file_id].executable
329
 
        else:
330
 
            path = self._inventory.id2path(file_id)
 
565
    else:
 
566
        def is_executable(self, file_id, path=None):
 
567
            if not path:
 
568
                path = self._inventory.id2path(file_id)
331
569
            mode = os.lstat(self.abspath(path)).st_mode
332
 
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC&mode)
 
570
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
333
571
 
334
572
    @needs_write_lock
335
573
    def add(self, files, ids=None):
369
607
 
370
608
        inv = self.read_working_inventory()
371
609
        for f,file_id in zip(files, ids):
372
 
            if is_control_file(f):
 
610
            if self.is_control_filename(f):
373
611
                raise BzrError("cannot add control file %s" % quotefn(f))
374
612
 
375
613
            fp = splitpath(f)
381
619
 
382
620
            try:
383
621
                kind = file_kind(fullpath)
384
 
            except OSError:
 
622
            except OSError, e:
 
623
                if e.errno == errno.ENOENT:
 
624
                    raise NoSuchFile(fullpath)
385
625
                # maybe something better?
386
626
                raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
387
627
 
390
630
                               'i.e. regular file, symlink or directory): %s' % quotefn(f))
391
631
 
392
632
            if file_id is None:
393
 
                file_id = gen_file_id(f)
394
 
            inv.add_path(f, kind=kind, file_id=file_id)
 
633
                inv.add_path(f, kind=kind)
 
634
            else:
 
635
                inv.add_path(f, kind=kind, file_id=file_id)
395
636
 
396
 
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
397
637
        self._write_inventory(inv)
398
638
 
399
639
    @needs_write_lock
410
650
        if updated:
411
651
            self.set_pending_merges(p)
412
652
 
 
653
    @needs_read_lock
413
654
    def pending_merges(self):
414
655
        """Return a list of pending merges.
415
656
 
416
657
        These are revisions that have been merged into the working
417
658
        directory but not yet committed.
418
659
        """
419
 
        cfn = self.branch._rel_controlfilename('pending-merges')
420
 
        if not self.branch._transport.has(cfn):
 
660
        try:
 
661
            merges_file = self._control_files.get_utf8('pending-merges')
 
662
        except OSError, e:
 
663
            if e.errno != errno.ENOENT:
 
664
                raise
421
665
            return []
422
666
        p = []
423
 
        for l in self.branch.controlfile('pending-merges', 'r').readlines():
 
667
        for l in merges_file.readlines():
424
668
            p.append(l.rstrip('\n'))
425
669
        return p
426
670
 
427
671
    @needs_write_lock
428
672
    def set_pending_merges(self, rev_list):
429
 
        self.branch.put_controlfile('pending-merges', '\n'.join(rev_list))
 
673
        self._control_files.put_utf8('pending-merges', '\n'.join(rev_list))
 
674
 
 
675
    @needs_write_lock
 
676
    def set_merge_modified(self, modified_hashes):
 
677
        def iter_stanzas():
 
678
            for file_id, hash in modified_hashes.iteritems():
 
679
                yield Stanza(file_id=file_id, hash=hash)
 
680
        self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
 
681
 
 
682
    @needs_write_lock
 
683
    def _put_rio(self, filename, stanzas, header):
 
684
        my_file = rio_file(stanzas, header)
 
685
        self._control_files.put(filename, my_file)
 
686
 
 
687
    @needs_read_lock
 
688
    def merge_modified(self):
 
689
        try:
 
690
            hashfile = self._control_files.get('merge-hashes')
 
691
        except NoSuchFile:
 
692
            return {}
 
693
        merge_hashes = {}
 
694
        try:
 
695
            if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
 
696
                raise MergeModifiedFormatError()
 
697
        except StopIteration:
 
698
            raise MergeModifiedFormatError()
 
699
        for s in RioReader(hashfile):
 
700
            file_id = s.get("file_id")
 
701
            if file_id not in self.inventory:
 
702
                continue
 
703
            hash = s.get("hash")
 
704
            if hash == self.get_file_sha1(file_id):
 
705
                merge_hashes[file_id] = hash
 
706
        return merge_hashes
430
707
 
431
708
    def get_symlink_target(self, file_id):
432
709
        return os.readlink(self.id2abspath(file_id))
439
716
        else:
440
717
            return '?'
441
718
 
442
 
 
443
719
    def list_files(self):
444
 
        """Recursively list all files as (path, class, kind, id).
 
720
        """Recursively list all files as (path, class, kind, id, entry).
445
721
 
446
722
        Lists, but does not descend into unversioned directories.
447
723
 
451
727
        Skips the control directory.
452
728
        """
453
729
        inv = self._inventory
454
 
 
455
 
        def descend(from_dir_relpath, from_dir_id, dp):
456
 
            ls = os.listdir(dp)
457
 
            ls.sort()
458
 
            for f in ls:
 
730
        # Convert these into local objects to save lookup times
 
731
        pathjoin = bzrlib.osutils.pathjoin
 
732
        file_kind = bzrlib.osutils.file_kind
 
733
 
 
734
        # transport.base ends in a slash, we want the piece
 
735
        # between the last two slashes
 
736
        transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
 
737
 
 
738
        fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
 
739
 
 
740
        # directory file_id, relative path, absolute path, reverse sorted children
 
741
        children = os.listdir(self.basedir)
 
742
        children.sort()
 
743
        # jam 20060527 The kernel sized tree seems equivalent whether we 
 
744
        # use a deque and popleft to keep them sorted, or if we use a plain
 
745
        # list and just reverse() them.
 
746
        children = collections.deque(children)
 
747
        stack = [(inv.root.file_id, u'', self.basedir, children)]
 
748
        while stack:
 
749
            from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
 
750
 
 
751
            while children:
 
752
                f = children.popleft()
459
753
                ## TODO: If we find a subdirectory with its own .bzr
460
754
                ## directory, then that is a separate tree and we
461
755
                ## should exclude it.
462
 
                if bzrlib.BZRDIR == f:
 
756
 
 
757
                # the bzrdir for this tree
 
758
                if transport_base_dir == f:
463
759
                    continue
464
760
 
465
 
                # path within tree
466
 
                fp = appendpath(from_dir_relpath, f)
 
761
                # we know that from_dir_relpath and from_dir_abspath never end in a slash
 
762
                # and 'f' doesn't begin with one, we can do a string op, rather
 
763
                # than the checks of pathjoin(), all relative paths will have an extra slash
 
764
                # at the beginning
 
765
                fp = from_dir_relpath + '/' + f
467
766
 
468
767
                # absolute path
469
 
                fap = appendpath(dp, f)
 
768
                fap = from_dir_abspath + '/' + f
470
769
                
471
770
                f_ie = inv.get_child(from_dir_id, f)
472
771
                if f_ie:
473
772
                    c = 'V'
474
 
                elif self.is_ignored(fp):
 
773
                elif self.is_ignored(fp[1:]):
475
774
                    c = 'I'
476
775
                else:
477
776
                    c = '?'
486
785
 
487
786
                # make a last minute entry
488
787
                if f_ie:
489
 
                    entry = f_ie
 
788
                    yield fp[1:], c, fk, f_ie.file_id, f_ie
490
789
                else:
491
 
                    if fk == 'directory':
492
 
                        entry = TreeDirectory()
493
 
                    elif fk == 'file':
494
 
                        entry = TreeFile()
495
 
                    elif fk == 'symlink':
496
 
                        entry = TreeLink()
497
 
                    else:
498
 
                        entry = TreeEntry()
 
790
                    try:
 
791
                        yield fp[1:], c, fk, None, fk_entries[fk]()
 
792
                    except KeyError:
 
793
                        yield fp[1:], c, fk, None, TreeEntry()
 
794
                    continue
499
795
                
500
 
                yield fp, c, fk, (f_ie and f_ie.file_id), entry
501
 
 
502
796
                if fk != 'directory':
503
797
                    continue
504
798
 
505
 
                if c != 'V':
506
 
                    # don't descend unversioned directories
507
 
                    continue
508
 
                
509
 
                for ff in descend(fp, f_ie.file_id, fap):
510
 
                    yield ff
 
799
                # But do this child first
 
800
                new_children = os.listdir(fap)
 
801
                new_children.sort()
 
802
                new_children = collections.deque(new_children)
 
803
                stack.append((f_ie.file_id, fp, fap, new_children))
 
804
                # Break out of inner loop, so that we start outer loop with child
 
805
                break
 
806
            else:
 
807
                # if we finished all children, pop it off the stack
 
808
                stack.pop()
511
809
 
512
 
        for f in descend(u'', inv.root.file_id, self.basedir):
513
 
            yield f
514
810
 
515
811
    @needs_write_lock
516
812
    def move(self, from_paths, to_name):
552
848
            if f_id == None:
553
849
                raise BzrError("%r is not versioned" % f)
554
850
            name_tail = splitpath(f)[-1]
555
 
            dest_path = appendpath(to_name, name_tail)
 
851
            dest_path = pathjoin(to_name, name_tail)
556
852
            if self.has_filename(dest_path):
557
853
                raise BzrError("destination %r already exists" % dest_path)
558
854
            if f_id in to_idpath:
565
861
        try:
566
862
            for f in from_paths:
567
863
                name_tail = splitpath(f)[-1]
568
 
                dest_path = appendpath(to_name, name_tail)
 
864
                dest_path = pathjoin(to_name, name_tail)
569
865
                result.append((f, dest_path))
570
866
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
571
867
                try:
636
932
        These are files in the working directory that are not versioned or
637
933
        control files or ignored.
638
934
        
639
 
        >>> from bzrlib.branch import ScratchBranch
640
 
        >>> b = ScratchBranch(files=['foo', 'foo~'])
641
 
        >>> tree = WorkingTree(b.base, b)
 
935
        >>> from bzrlib.bzrdir import ScratchDir
 
936
        >>> d = ScratchDir(files=['foo', 'foo~'])
 
937
        >>> b = d.open_branch()
 
938
        >>> tree = d.open_workingtree()
642
939
        >>> map(str, tree.unknowns())
643
940
        ['foo']
644
941
        >>> tree.add('foo')
652
949
            if not self.is_ignored(subp):
653
950
                yield subp
654
951
 
 
952
    @deprecated_method(zero_eight)
655
953
    def iter_conflicts(self):
 
954
        """List all files in the tree that have text or content conflicts.
 
955
        DEPRECATED.  Use conflicts instead."""
 
956
        return self._iter_conflicts()
 
957
 
 
958
    def _iter_conflicts(self):
656
959
        conflicted = set()
657
 
        for path in (s[0] for s in self.list_files()):
 
960
        for info in self.list_files():
 
961
            path = info[0]
658
962
            stem = get_conflicted_stem(path)
659
963
            if stem is None:
660
964
                continue
663
967
                yield stem
664
968
 
665
969
    @needs_write_lock
666
 
    def pull(self, source, overwrite=False):
667
 
        from bzrlib.merge import merge_inner
 
970
    def pull(self, source, overwrite=False, stop_revision=None):
 
971
        top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
668
972
        source.lock_read()
669
973
        try:
 
974
            pp = ProgressPhase("Pull phase", 2, top_pb)
 
975
            pp.next_phase()
670
976
            old_revision_history = self.branch.revision_history()
671
 
            count = self.branch.pull(source, overwrite)
 
977
            basis_tree = self.basis_tree()
 
978
            count = self.branch.pull(source, overwrite, stop_revision)
672
979
            new_revision_history = self.branch.revision_history()
673
980
            if new_revision_history != old_revision_history:
 
981
                pp.next_phase()
674
982
                if len(old_revision_history):
675
983
                    other_revision = old_revision_history[-1]
676
984
                else:
677
985
                    other_revision = None
678
 
                merge_inner(self.branch,
679
 
                            self.branch.basis_tree(), 
680
 
                            self.branch.revision_tree(other_revision))
 
986
                repository = self.branch.repository
 
987
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
988
                try:
 
989
                    merge_inner(self.branch,
 
990
                                self.branch.basis_tree(),
 
991
                                basis_tree, 
 
992
                                this_tree=self, 
 
993
                                pb=pb)
 
994
                finally:
 
995
                    pb.finished()
 
996
                self.set_last_revision(self.branch.last_revision())
681
997
            return count
682
998
        finally:
683
999
            source.unlock()
 
1000
            top_pb.finished()
684
1001
 
685
1002
    def extras(self):
686
1003
        """Yield all unknown files in this WorkingTree.
707
1024
            
708
1025
            fl.sort()
709
1026
            for subf in fl:
710
 
                subp = appendpath(path, subf)
 
1027
                subp = pathjoin(path, subf)
711
1028
                yield subp
712
1029
 
 
1030
    def _translate_ignore_rule(self, rule):
 
1031
        """Translate a single ignore rule to a regex.
 
1032
 
 
1033
        There are two types of ignore rules.  Those that do not contain a / are
 
1034
        matched against the tail of the filename (that is, they do not care
 
1035
        what directory the file is in.)  Rules which do contain a slash must
 
1036
        match the entire path.  As a special case, './' at the start of the
 
1037
        string counts as a slash in the string but is removed before matching
 
1038
        (e.g. ./foo.c, ./src/foo.c)
 
1039
 
 
1040
        :return: The translated regex.
 
1041
        """
 
1042
        if rule[:2] in ('./', '.\\'):
 
1043
            # rootdir rule
 
1044
            result = fnmatch.translate(rule[2:])
 
1045
        elif '/' in rule or '\\' in rule:
 
1046
            # path prefix 
 
1047
            result = fnmatch.translate(rule)
 
1048
        else:
 
1049
            # default rule style.
 
1050
            result = "(?:.*/)?(?!.*/)" + fnmatch.translate(rule)
 
1051
        assert result[-1] == '$', "fnmatch.translate did not add the expected $"
 
1052
        return "(" + result + ")"
 
1053
 
 
1054
    def _combine_ignore_rules(self, rules):
 
1055
        """Combine a list of ignore rules into a single regex object.
 
1056
 
 
1057
        Each individual rule is combined with | to form a big regex, which then
 
1058
        has $ added to it to form something like ()|()|()$. The group index for
 
1059
        each subregex's outermost group is placed in a dictionary mapping back 
 
1060
        to the rule. This allows quick identification of the matching rule that
 
1061
        triggered a match.
 
1062
        :return: a list of the compiled regex and the matching-group index 
 
1063
        dictionaries. We return a list because python complains if you try to 
 
1064
        combine more than 100 regexes.
 
1065
        """
 
1066
        result = []
 
1067
        groups = {}
 
1068
        next_group = 0
 
1069
        translated_rules = []
 
1070
        for rule in rules:
 
1071
            translated_rule = self._translate_ignore_rule(rule)
 
1072
            compiled_rule = re.compile(translated_rule)
 
1073
            groups[next_group] = rule
 
1074
            next_group += compiled_rule.groups
 
1075
            translated_rules.append(translated_rule)
 
1076
            if next_group == 99:
 
1077
                result.append((re.compile("|".join(translated_rules)), groups))
 
1078
                groups = {}
 
1079
                next_group = 0
 
1080
                translated_rules = []
 
1081
        if len(translated_rules):
 
1082
            result.append((re.compile("|".join(translated_rules)), groups))
 
1083
        return result
713
1084
 
714
1085
    def ignored_files(self):
715
1086
        """Yield list of PATH, IGNORE_PATTERN"""
718
1089
            if pat != None:
719
1090
                yield subp, pat
720
1091
 
721
 
 
722
1092
    def get_ignore_list(self):
723
1093
        """Return list of ignore patterns.
724
1094
 
730
1100
        l = bzrlib.DEFAULT_IGNORE[:]
731
1101
        if self.has_filename(bzrlib.IGNORE_FILENAME):
732
1102
            f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
733
 
            l.extend([line.rstrip("\n\r") for line in f.readlines()])
 
1103
            l.extend([line.rstrip("\n\r").decode('utf-8') 
 
1104
                      for line in f.readlines()])
734
1105
        self._ignorelist = l
 
1106
        self._ignore_regex = self._combine_ignore_rules(l)
735
1107
        return l
736
1108
 
 
1109
    def _get_ignore_rules_as_regex(self):
 
1110
        """Return a regex of the ignore rules and a mapping dict.
 
1111
 
 
1112
        :return: (ignore rules compiled regex, dictionary mapping rule group 
 
1113
        indices to original rule.)
 
1114
        """
 
1115
        if getattr(self, '_ignorelist', None) is None:
 
1116
            self.get_ignore_list()
 
1117
        return self._ignore_regex
737
1118
 
738
1119
    def is_ignored(self, filename):
739
1120
        r"""Check whether the filename matches an ignore pattern.
753
1134
        # treat dotfiles correctly and allows * to match /.
754
1135
        # Eventually it should be replaced with something more
755
1136
        # accurate.
756
 
        
757
 
        for pat in self.get_ignore_list():
758
 
            if '/' in pat or '\\' in pat:
759
 
                
760
 
                # as a special case, you can put ./ at the start of a
761
 
                # pattern; this is good to match in the top-level
762
 
                # only;
763
 
                
764
 
                if (pat[:2] == './') or (pat[:2] == '.\\'):
765
 
                    newpat = pat[2:]
766
 
                else:
767
 
                    newpat = pat
768
 
                if fnmatch.fnmatchcase(filename, newpat):
769
 
                    return pat
770
 
            else:
771
 
                if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
772
 
                    return pat
773
 
        else:
774
 
            return None
 
1137
    
 
1138
        rules = self._get_ignore_rules_as_regex()
 
1139
        for regex, mapping in rules:
 
1140
            match = regex.match(filename)
 
1141
            if match is not None:
 
1142
                # one or more of the groups in mapping will have a non-None group 
 
1143
                # match.
 
1144
                groups = match.groups()
 
1145
                rules = [mapping[group] for group in 
 
1146
                    mapping if groups[group] is not None]
 
1147
                return rules[0]
 
1148
        return None
775
1149
 
776
1150
    def kind(self, file_id):
777
1151
        return file_kind(self.id2abspath(file_id))
778
1152
 
 
1153
    @needs_read_lock
 
1154
    def last_revision(self):
 
1155
        """Return the last revision id of this working tree.
 
1156
 
 
1157
        In early branch formats this was == the branch last_revision,
 
1158
        but that cannot be relied upon - for working tree operations,
 
1159
        always use tree.last_revision().
 
1160
        """
 
1161
        return self.branch.last_revision()
 
1162
 
 
1163
    def is_locked(self):
 
1164
        return self._control_files.is_locked()
 
1165
 
779
1166
    def lock_read(self):
780
1167
        """See Branch.lock_read, and WorkingTree.unlock."""
781
 
        return self.branch.lock_read()
 
1168
        self.branch.lock_read()
 
1169
        try:
 
1170
            return self._control_files.lock_read()
 
1171
        except:
 
1172
            self.branch.unlock()
 
1173
            raise
782
1174
 
783
1175
    def lock_write(self):
784
1176
        """See Branch.lock_write, and WorkingTree.unlock."""
785
 
        return self.branch.lock_write()
786
 
 
787
 
    def _basis_inventory_name(self, revision_id):
788
 
        return 'basis-inventory.%s' % revision_id
789
 
 
790
 
    def set_last_revision(self, new_revision, old_revision=None):
791
 
        if old_revision:
792
 
            try:
793
 
                path = self._basis_inventory_name(old_revision)
794
 
                path = self.branch._rel_controlfilename(path)
795
 
                self.branch._transport.delete(path)
796
 
            except:
797
 
                pass
798
 
        try:
799
 
            xml = self.branch.get_inventory_xml(new_revision)
800
 
            path = self._basis_inventory_name(new_revision)
801
 
            self.branch.put_controlfile(path, xml)
 
1177
        self.branch.lock_write()
 
1178
        try:
 
1179
            return self._control_files.lock_write()
 
1180
        except:
 
1181
            self.branch.unlock()
 
1182
            raise
 
1183
 
 
1184
    def get_physical_lock_status(self):
 
1185
        return self._control_files.get_physical_lock_status()
 
1186
 
 
1187
    def _basis_inventory_name(self):
 
1188
        return 'basis-inventory'
 
1189
 
 
1190
    @needs_write_lock
 
1191
    def set_last_revision(self, new_revision):
 
1192
        """Change the last revision in the working tree."""
 
1193
        if self._change_last_revision(new_revision):
 
1194
            self._cache_basis_inventory(new_revision)
 
1195
 
 
1196
    def _change_last_revision(self, new_revision):
 
1197
        """Template method part of set_last_revision to perform the change.
 
1198
        
 
1199
        This is used to allow WorkingTree3 instances to not affect branch
 
1200
        when their last revision is set.
 
1201
        """
 
1202
        if new_revision is None:
 
1203
            self.branch.set_revision_history([])
 
1204
            return False
 
1205
        # current format is locked in with the branch
 
1206
        revision_history = self.branch.revision_history()
 
1207
        try:
 
1208
            position = revision_history.index(new_revision)
 
1209
        except ValueError:
 
1210
            raise errors.NoSuchRevision(self.branch, new_revision)
 
1211
        self.branch.set_revision_history(revision_history[:position + 1])
 
1212
        return True
 
1213
 
 
1214
    def _cache_basis_inventory(self, new_revision):
 
1215
        """Cache new_revision as the basis inventory."""
 
1216
        # TODO: this should allow the ready-to-use inventory to be passed in,
 
1217
        # as commit already has that ready-to-use [while the format is the
 
1218
        # same, that is].
 
1219
        try:
 
1220
            # this double handles the inventory - unpack and repack - 
 
1221
            # but is easier to understand. We can/should put a conditional
 
1222
            # in here based on whether the inventory is in the latest format
 
1223
            # - perhaps we should repack all inventories on a repository
 
1224
            # upgrade ?
 
1225
            # the fast path is to copy the raw xml from the repository. If the
 
1226
            # xml contains 'revision_id="', then we assume the right 
 
1227
            # revision_id is set. We must check for this full string, because a
 
1228
            # root node id can legitimately look like 'revision_id' but cannot
 
1229
            # contain a '"'.
 
1230
            xml = self.branch.repository.get_inventory_xml(new_revision)
 
1231
            if not 'revision_id="' in xml.split('\n', 1)[0]:
 
1232
                inv = self.branch.repository.deserialise_inventory(
 
1233
                    new_revision, xml)
 
1234
                inv.revision_id = new_revision
 
1235
                xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
 
1236
            assert isinstance(xml, str), 'serialised xml must be bytestring.'
 
1237
            path = self._basis_inventory_name()
 
1238
            sio = StringIO(xml)
 
1239
            self._control_files.put(path, sio)
802
1240
        except WeaveRevisionNotPresent:
803
1241
            pass
804
1242
 
805
 
    def read_basis_inventory(self, revision_id):
 
1243
    def read_basis_inventory(self):
806
1244
        """Read the cached basis inventory."""
807
 
        path = self._basis_inventory_name(revision_id)
808
 
        return self.branch.controlfile(path, 'r').read()
 
1245
        path = self._basis_inventory_name()
 
1246
        return self._control_files.get(path).read()
809
1247
        
810
1248
    @needs_read_lock
811
1249
    def read_working_inventory(self):
812
1250
        """Read the working inventory."""
813
1251
        # ElementTree does its own conversion from UTF-8, so open in
814
1252
        # binary.
815
 
        f = self.branch.controlfile('inventory', 'rb')
816
 
        return bzrlib.xml5.serializer_v5.read_inventory(f)
 
1253
        result = bzrlib.xml5.serializer_v5.read_inventory(
 
1254
            self._control_files.get('inventory'))
 
1255
        self._set_inventory(result)
 
1256
        return result
817
1257
 
818
1258
    @needs_write_lock
819
 
    def remove(self, files, verbose=False):
 
1259
    def remove(self, files, verbose=False, to_file=None):
820
1260
        """Remove nominated files from the working inventory..
821
1261
 
822
1262
        This does not remove their text.  This does not run on XXX on what? RBC
851
1291
                    new_status = 'I'
852
1292
                else:
853
1293
                    new_status = '?'
854
 
                show_status(new_status, inv[fid].kind, quotefn(f))
 
1294
                show_status(new_status, inv[fid].kind, quotefn(f), to_file=to_file)
855
1295
            del inv[fid]
856
1296
 
857
1297
        self._write_inventory(inv)
858
1298
 
859
1299
    @needs_write_lock
860
 
    def revert(self, filenames, old_tree=None, backups=True):
861
 
        from bzrlib.merge import merge_inner
 
1300
    def revert(self, filenames, old_tree=None, backups=True, 
 
1301
               pb=DummyProgress()):
 
1302
        from transform import revert
 
1303
        from conflicts import resolve
862
1304
        if old_tree is None:
863
 
            old_tree = self.branch.basis_tree()
864
 
        merge_inner(self.branch, old_tree,
865
 
                    self, ignore_zero=True,
866
 
                    backup_files=backups, 
867
 
                    interesting_files=filenames)
 
1305
            old_tree = self.basis_tree()
 
1306
        conflicts = revert(self, old_tree, filenames, backups, pb)
868
1307
        if not len(filenames):
869
1308
            self.set_pending_merges([])
 
1309
            resolve(self)
 
1310
        else:
 
1311
            resolve(self, filenames, ignore_misses=True)
 
1312
        return conflicts
870
1313
 
 
1314
    # XXX: This method should be deprecated in favour of taking in a proper
 
1315
    # new Inventory object.
871
1316
    @needs_write_lock
872
1317
    def set_inventory(self, new_inventory_list):
873
1318
        from bzrlib.inventory import (Inventory,
901
1346
        inv._byid[inv.root.file_id] = inv.root
902
1347
        for fid in inv:
903
1348
            entry = inv[fid]
904
 
            if entry.parent_id in (None, orig_root_id):
 
1349
            if entry.parent_id == orig_root_id:
905
1350
                entry.parent_id = inv.root.file_id
906
1351
        self._write_inventory(inv)
907
1352
 
914
1359
        between multiple working trees, i.e. via shared storage, then we 
915
1360
        would probably want to lock both the local tree, and the branch.
916
1361
        """
917
 
        if self._hashcache.needs_write:
 
1362
        # FIXME: We want to write out the hashcache only when the last lock on
 
1363
        # this working copy is released.  Peeking at the lock count is a bit
 
1364
        # of a nasty hack; probably it's better to have a transaction object,
 
1365
        # which can do some finalization when it's either successfully or
 
1366
        # unsuccessfully completed.  (Denys's original patch did that.)
 
1367
        # RBC 20060206 hooking into transaction will couple lock and transaction
 
1368
        # wrongly. Hooking into unlock on the control files object is fine though.
 
1369
        
 
1370
        # TODO: split this per format so there is no ugly if block
 
1371
        if self._hashcache.needs_write and (
 
1372
            # dedicated lock files
 
1373
            self._control_files._lock_count==1 or 
 
1374
            # shared lock files
 
1375
            (self._control_files is self.branch.control_files and 
 
1376
             self._control_files._lock_count==3)):
918
1377
            self._hashcache.write()
919
 
        return self.branch.unlock()
 
1378
        # reverse order of locking.
 
1379
        try:
 
1380
            return self._control_files.unlock()
 
1381
        finally:
 
1382
            self.branch.unlock()
 
1383
 
 
1384
    @needs_write_lock
 
1385
    def update(self):
 
1386
        """Update a working tree along its branch.
 
1387
 
 
1388
        This will update the branch if its bound too, which means we have multiple trees involved:
 
1389
        The new basis tree of the master.
 
1390
        The old basis tree of the branch.
 
1391
        The old basis tree of the working tree.
 
1392
        The current working tree state.
 
1393
        pathologically all three may be different, and non ancestors of each other.
 
1394
        Conceptually we want to:
 
1395
        Preserve the wt.basis->wt.state changes
 
1396
        Transform the wt.basis to the new master basis.
 
1397
        Apply a merge of the old branch basis to get any 'local' changes from it into the tree.
 
1398
        Restore the wt.basis->wt.state changes.
 
1399
 
 
1400
        There isn't a single operation at the moment to do that, so we:
 
1401
        Merge current state -> basis tree of the master w.r.t. the old tree basis.
 
1402
        Do a 'normal' merge of the old branch basis if it is relevant.
 
1403
        """
 
1404
        old_tip = self.branch.update()
 
1405
        if old_tip is not None:
 
1406
            self.add_pending_merge(old_tip)
 
1407
        self.branch.lock_read()
 
1408
        try:
 
1409
            result = 0
 
1410
            if self.last_revision() != self.branch.last_revision():
 
1411
                # merge tree state up to new branch tip.
 
1412
                basis = self.basis_tree()
 
1413
                to_tree = self.branch.basis_tree()
 
1414
                result += merge_inner(self.branch,
 
1415
                                      to_tree,
 
1416
                                      basis,
 
1417
                                      this_tree=self)
 
1418
                self.set_last_revision(self.branch.last_revision())
 
1419
            if old_tip and old_tip != self.last_revision():
 
1420
                # our last revision was not the prior branch last revision
 
1421
                # and we have converted that last revision to a pending merge.
 
1422
                # base is somewhere between the branch tip now
 
1423
                # and the now pending merge
 
1424
                from bzrlib.revision import common_ancestor
 
1425
                try:
 
1426
                    base_rev_id = common_ancestor(self.branch.last_revision(),
 
1427
                                                  old_tip,
 
1428
                                                  self.branch.repository)
 
1429
                except errors.NoCommonAncestor:
 
1430
                    base_rev_id = None
 
1431
                base_tree = self.branch.repository.revision_tree(base_rev_id)
 
1432
                other_tree = self.branch.repository.revision_tree(old_tip)
 
1433
                result += merge_inner(self.branch,
 
1434
                                      other_tree,
 
1435
                                      base_tree,
 
1436
                                      this_tree=self)
 
1437
            return result
 
1438
        finally:
 
1439
            self.branch.unlock()
920
1440
 
921
1441
    @needs_write_lock
922
1442
    def _write_inventory(self, inv):
923
1443
        """Write inventory as the current inventory."""
924
 
        from cStringIO import StringIO
925
 
        from bzrlib.atomicfile import AtomicFile
926
1444
        sio = StringIO()
927
1445
        bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
928
1446
        sio.seek(0)
929
 
        f = AtomicFile(self.branch.controlfilename('inventory'))
930
 
        try:
931
 
            pumpfile(sio, f)
932
 
            f.commit()
933
 
        finally:
934
 
            f.close()
 
1447
        self._control_files.put('inventory', sio)
935
1448
        self._set_inventory(inv)
936
1449
        mutter('wrote working inventory')
937
 
            
938
 
 
939
 
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
 
1450
 
 
1451
    def set_conflicts(self, arg):
 
1452
        raise UnsupportedOperation(self.set_conflicts, self)
 
1453
 
 
1454
    @needs_read_lock
 
1455
    def conflicts(self):
 
1456
        conflicts = ConflictList()
 
1457
        for conflicted in self._iter_conflicts():
 
1458
            text = True
 
1459
            try:
 
1460
                if file_kind(self.abspath(conflicted)) != "file":
 
1461
                    text = False
 
1462
            except errors.NoSuchFile:
 
1463
                text = False
 
1464
            if text is True:
 
1465
                for suffix in ('.THIS', '.OTHER'):
 
1466
                    try:
 
1467
                        kind = file_kind(self.abspath(conflicted+suffix))
 
1468
                        if kind != "file":
 
1469
                            text = False
 
1470
                    except errors.NoSuchFile:
 
1471
                        text = False
 
1472
                    if text == False:
 
1473
                        break
 
1474
            ctype = {True: 'text conflict', False: 'contents conflict'}[text]
 
1475
            conflicts.append(Conflict.factory(ctype, path=conflicted,
 
1476
                             file_id=self.path2id(conflicted)))
 
1477
        return conflicts
 
1478
 
 
1479
 
 
1480
class WorkingTree3(WorkingTree):
 
1481
    """This is the Format 3 working tree.
 
1482
 
 
1483
    This differs from the base WorkingTree by:
 
1484
     - having its own file lock
 
1485
     - having its own last-revision property.
 
1486
 
 
1487
    This is new in bzr 0.8
 
1488
    """
 
1489
 
 
1490
    @needs_read_lock
 
1491
    def last_revision(self):
 
1492
        """See WorkingTree.last_revision."""
 
1493
        try:
 
1494
            return self._control_files.get_utf8('last-revision').read()
 
1495
        except NoSuchFile:
 
1496
            return None
 
1497
 
 
1498
    def _change_last_revision(self, revision_id):
 
1499
        """See WorkingTree._change_last_revision."""
 
1500
        if revision_id is None or revision_id == NULL_REVISION:
 
1501
            try:
 
1502
                self._control_files._transport.delete('last-revision')
 
1503
            except errors.NoSuchFile:
 
1504
                pass
 
1505
            return False
 
1506
        else:
 
1507
            try:
 
1508
                self.branch.revision_history().index(revision_id)
 
1509
            except ValueError:
 
1510
                raise errors.NoSuchRevision(self.branch, revision_id)
 
1511
            self._control_files.put_utf8('last-revision', revision_id)
 
1512
            return True
 
1513
 
 
1514
    @needs_write_lock
 
1515
    def set_conflicts(self, conflicts):
 
1516
        self._put_rio('conflicts', conflicts.to_stanzas(), 
 
1517
                      CONFLICT_HEADER_1)
 
1518
 
 
1519
    @needs_read_lock
 
1520
    def conflicts(self):
 
1521
        try:
 
1522
            confile = self._control_files.get('conflicts')
 
1523
        except NoSuchFile:
 
1524
            return ConflictList()
 
1525
        try:
 
1526
            if confile.next() != CONFLICT_HEADER_1 + '\n':
 
1527
                raise ConflictFormatError()
 
1528
        except StopIteration:
 
1529
            raise ConflictFormatError()
 
1530
        return ConflictList.from_stanzas(RioReader(confile))
 
1531
 
 
1532
 
940
1533
def get_conflicted_stem(path):
941
1534
    for suffix in CONFLICT_SUFFIXES:
942
1535
        if path.endswith(suffix):
943
1536
            return path[:-len(suffix)]
 
1537
 
 
1538
@deprecated_function(zero_eight)
 
1539
def is_control_file(filename):
 
1540
    """See WorkingTree.is_control_filename(filename)."""
 
1541
    ## FIXME: better check
 
1542
    filename = normpath(filename)
 
1543
    while filename != '':
 
1544
        head, tail = os.path.split(filename)
 
1545
        ## mutter('check %r for control file' % ((head, tail),))
 
1546
        if tail == '.bzr':
 
1547
            return True
 
1548
        if filename == head:
 
1549
            break
 
1550
        filename = head
 
1551
    return False
 
1552
 
 
1553
 
 
1554
class WorkingTreeFormat(object):
 
1555
    """An encapsulation of the initialization and open routines for a format.
 
1556
 
 
1557
    Formats provide three things:
 
1558
     * An initialization routine,
 
1559
     * a format string,
 
1560
     * an open routine.
 
1561
 
 
1562
    Formats are placed in an dict by their format string for reference 
 
1563
    during workingtree opening. Its not required that these be instances, they
 
1564
    can be classes themselves with class methods - it simply depends on 
 
1565
    whether state is needed for a given format or not.
 
1566
 
 
1567
    Once a format is deprecated, just deprecate the initialize and open
 
1568
    methods on the format class. Do not deprecate the object, as the 
 
1569
    object will be created every time regardless.
 
1570
    """
 
1571
 
 
1572
    _default_format = None
 
1573
    """The default format used for new trees."""
 
1574
 
 
1575
    _formats = {}
 
1576
    """The known formats."""
 
1577
 
 
1578
    @classmethod
 
1579
    def find_format(klass, a_bzrdir):
 
1580
        """Return the format for the working tree object in a_bzrdir."""
 
1581
        try:
 
1582
            transport = a_bzrdir.get_workingtree_transport(None)
 
1583
            format_string = transport.get("format").read()
 
1584
            return klass._formats[format_string]
 
1585
        except NoSuchFile:
 
1586
            raise errors.NoWorkingTree(base=transport.base)
 
1587
        except KeyError:
 
1588
            raise errors.UnknownFormatError(format=format_string)
 
1589
 
 
1590
    @classmethod
 
1591
    def get_default_format(klass):
 
1592
        """Return the current default format."""
 
1593
        return klass._default_format
 
1594
 
 
1595
    def get_format_string(self):
 
1596
        """Return the ASCII format string that identifies this format."""
 
1597
        raise NotImplementedError(self.get_format_string)
 
1598
 
 
1599
    def get_format_description(self):
 
1600
        """Return the short description for this format."""
 
1601
        raise NotImplementedError(self.get_format_description)
 
1602
 
 
1603
    def is_supported(self):
 
1604
        """Is this format supported?
 
1605
 
 
1606
        Supported formats can be initialized and opened.
 
1607
        Unsupported formats may not support initialization or committing or 
 
1608
        some other features depending on the reason for not being supported.
 
1609
        """
 
1610
        return True
 
1611
 
 
1612
    @classmethod
 
1613
    def register_format(klass, format):
 
1614
        klass._formats[format.get_format_string()] = format
 
1615
 
 
1616
    @classmethod
 
1617
    def set_default_format(klass, format):
 
1618
        klass._default_format = format
 
1619
 
 
1620
    @classmethod
 
1621
    def unregister_format(klass, format):
 
1622
        assert klass._formats[format.get_format_string()] is format
 
1623
        del klass._formats[format.get_format_string()]
 
1624
 
 
1625
 
 
1626
 
 
1627
class WorkingTreeFormat2(WorkingTreeFormat):
 
1628
    """The second working tree format. 
 
1629
 
 
1630
    This format modified the hash cache from the format 1 hash cache.
 
1631
    """
 
1632
 
 
1633
    def get_format_description(self):
 
1634
        """See WorkingTreeFormat.get_format_description()."""
 
1635
        return "Working tree format 2"
 
1636
 
 
1637
    def stub_initialize_remote(self, control_files):
 
1638
        """As a special workaround create critical control files for a remote working tree
 
1639
        
 
1640
        This ensures that it can later be updated and dealt with locally,
 
1641
        since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with 
 
1642
        no working tree.  (See bug #43064).
 
1643
        """
 
1644
        sio = StringIO()
 
1645
        inv = Inventory()
 
1646
        bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
 
1647
        sio.seek(0)
 
1648
        control_files.put('inventory', sio)
 
1649
 
 
1650
        control_files.put_utf8('pending-merges', '')
 
1651
        
 
1652
 
 
1653
    def initialize(self, a_bzrdir, revision_id=None):
 
1654
        """See WorkingTreeFormat.initialize()."""
 
1655
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1656
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1657
        branch = a_bzrdir.open_branch()
 
1658
        if revision_id is not None:
 
1659
            branch.lock_write()
 
1660
            try:
 
1661
                revision_history = branch.revision_history()
 
1662
                try:
 
1663
                    position = revision_history.index(revision_id)
 
1664
                except ValueError:
 
1665
                    raise errors.NoSuchRevision(branch, revision_id)
 
1666
                branch.set_revision_history(revision_history[:position + 1])
 
1667
            finally:
 
1668
                branch.unlock()
 
1669
        revision = branch.last_revision()
 
1670
        inv = Inventory() 
 
1671
        wt = WorkingTree(a_bzrdir.root_transport.local_abspath('.'),
 
1672
                         branch,
 
1673
                         inv,
 
1674
                         _internal=True,
 
1675
                         _format=self,
 
1676
                         _bzrdir=a_bzrdir)
 
1677
        wt._write_inventory(inv)
 
1678
        wt.set_root_id(inv.root.file_id)
 
1679
        wt.set_last_revision(revision)
 
1680
        wt.set_pending_merges([])
 
1681
        build_tree(wt.basis_tree(), wt)
 
1682
        return wt
 
1683
 
 
1684
    def __init__(self):
 
1685
        super(WorkingTreeFormat2, self).__init__()
 
1686
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
 
1687
 
 
1688
    def open(self, a_bzrdir, _found=False):
 
1689
        """Return the WorkingTree object for a_bzrdir
 
1690
 
 
1691
        _found is a private parameter, do not use it. It is used to indicate
 
1692
               if format probing has already been done.
 
1693
        """
 
1694
        if not _found:
 
1695
            # we are being called directly and must probe.
 
1696
            raise NotImplementedError
 
1697
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1698
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1699
        return WorkingTree(a_bzrdir.root_transport.local_abspath('.'),
 
1700
                           _internal=True,
 
1701
                           _format=self,
 
1702
                           _bzrdir=a_bzrdir)
 
1703
 
 
1704
 
 
1705
class WorkingTreeFormat3(WorkingTreeFormat):
 
1706
    """The second working tree format updated to record a format marker.
 
1707
 
 
1708
    This format:
 
1709
        - exists within a metadir controlling .bzr
 
1710
        - includes an explicit version marker for the workingtree control
 
1711
          files, separate from the BzrDir format
 
1712
        - modifies the hash cache format
 
1713
        - is new in bzr 0.8
 
1714
        - uses a LockDir to guard access to the repository
 
1715
    """
 
1716
 
 
1717
    def get_format_string(self):
 
1718
        """See WorkingTreeFormat.get_format_string()."""
 
1719
        return "Bazaar-NG Working Tree format 3"
 
1720
 
 
1721
    def get_format_description(self):
 
1722
        """See WorkingTreeFormat.get_format_description()."""
 
1723
        return "Working tree format 3"
 
1724
 
 
1725
    _lock_file_name = 'lock'
 
1726
    _lock_class = LockDir
 
1727
 
 
1728
    def _open_control_files(self, a_bzrdir):
 
1729
        transport = a_bzrdir.get_workingtree_transport(None)
 
1730
        return LockableFiles(transport, self._lock_file_name, 
 
1731
                             self._lock_class)
 
1732
 
 
1733
    def initialize(self, a_bzrdir, revision_id=None):
 
1734
        """See WorkingTreeFormat.initialize().
 
1735
        
 
1736
        revision_id allows creating a working tree at a different
 
1737
        revision than the branch is at.
 
1738
        """
 
1739
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1740
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1741
        transport = a_bzrdir.get_workingtree_transport(self)
 
1742
        control_files = self._open_control_files(a_bzrdir)
 
1743
        control_files.create_lock()
 
1744
        control_files.lock_write()
 
1745
        control_files.put_utf8('format', self.get_format_string())
 
1746
        branch = a_bzrdir.open_branch()
 
1747
        if revision_id is None:
 
1748
            revision_id = branch.last_revision()
 
1749
        inv = Inventory() 
 
1750
        wt = WorkingTree3(a_bzrdir.root_transport.local_abspath('.'),
 
1751
                         branch,
 
1752
                         inv,
 
1753
                         _internal=True,
 
1754
                         _format=self,
 
1755
                         _bzrdir=a_bzrdir,
 
1756
                         _control_files=control_files)
 
1757
        wt.lock_write()
 
1758
        try:
 
1759
            wt._write_inventory(inv)
 
1760
            wt.set_root_id(inv.root.file_id)
 
1761
            wt.set_last_revision(revision_id)
 
1762
            wt.set_pending_merges([])
 
1763
            build_tree(wt.basis_tree(), wt)
 
1764
        finally:
 
1765
            wt.unlock()
 
1766
            control_files.unlock()
 
1767
        return wt
 
1768
 
 
1769
    def __init__(self):
 
1770
        super(WorkingTreeFormat3, self).__init__()
 
1771
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1772
 
 
1773
    def open(self, a_bzrdir, _found=False):
 
1774
        """Return the WorkingTree object for a_bzrdir
 
1775
 
 
1776
        _found is a private parameter, do not use it. It is used to indicate
 
1777
               if format probing has already been done.
 
1778
        """
 
1779
        if not _found:
 
1780
            # we are being called directly and must probe.
 
1781
            raise NotImplementedError
 
1782
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1783
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1784
        control_files = self._open_control_files(a_bzrdir)
 
1785
        return WorkingTree3(a_bzrdir.root_transport.local_abspath('.'),
 
1786
                           _internal=True,
 
1787
                           _format=self,
 
1788
                           _bzrdir=a_bzrdir,
 
1789
                           _control_files=control_files)
 
1790
 
 
1791
    def __str__(self):
 
1792
        return self.get_format_string()
 
1793
 
 
1794
 
 
1795
# formats which have no format string are not discoverable
 
1796
# and not independently creatable, so are not registered.
 
1797
__default_format = WorkingTreeFormat3()
 
1798
WorkingTreeFormat.register_format(__default_format)
 
1799
WorkingTreeFormat.set_default_format(__default_format)
 
1800
_legacy_formats = [WorkingTreeFormat2(),
 
1801
                   ]
 
1802
 
 
1803
 
 
1804
class WorkingTreeTestProviderAdapter(object):
 
1805
    """A tool to generate a suite testing multiple workingtree formats at once.
 
1806
 
 
1807
    This is done by copying the test once for each transport and injecting
 
1808
    the transport_server, transport_readonly_server, and workingtree_format
 
1809
    classes into each copy. Each copy is also given a new id() to make it
 
1810
    easy to identify.
 
1811
    """
 
1812
 
 
1813
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1814
        self._transport_server = transport_server
 
1815
        self._transport_readonly_server = transport_readonly_server
 
1816
        self._formats = formats
 
1817
    
 
1818
    def adapt(self, test):
 
1819
        from bzrlib.tests import TestSuite
 
1820
        result = TestSuite()
 
1821
        for workingtree_format, bzrdir_format in self._formats:
 
1822
            new_test = deepcopy(test)
 
1823
            new_test.transport_server = self._transport_server
 
1824
            new_test.transport_readonly_server = self._transport_readonly_server
 
1825
            new_test.bzrdir_format = bzrdir_format
 
1826
            new_test.workingtree_format = workingtree_format
 
1827
            def make_new_test_id():
 
1828
                new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
 
1829
                return lambda: new_id
 
1830
            new_test.id = make_new_test_id()
 
1831
            result.addTest(new_test)
 
1832
        return result