/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

Merge from dirstate

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""WorkingTree object and friends.
 
18
 
 
19
A WorkingTree represents the editable working copy of a branch.
 
20
Operations which represent the WorkingTree are also done here, 
 
21
such as renaming or adding files.  The WorkingTree has an inventory 
 
22
which is updated by these operations.  A commit produces a 
 
23
new revision based on the workingtree and its inventory.
 
24
 
 
25
At the moment every WorkingTree has its own branch.  Remote
 
26
WorkingTrees aren't supported.
 
27
 
 
28
To get a WorkingTree, call bzrdir.open_workingtree() or
 
29
WorkingTree.open(dir).
 
30
"""
 
31
 
 
32
# TODO: Give the workingtree sole responsibility for the working inventory;
 
33
# remove the variable and references to it from the branch.  This may require
 
34
# updating the commit code so as to update the inventory within the working
 
35
# copy, and making sure there's only one WorkingTree for any directory on disk.
 
36
# At the moment they may alias the inventory and have old copies of it in
 
37
# memory.  (Now done? -- mbp 20060309)
 
38
 
 
39
from cStringIO import StringIO
 
40
import os
 
41
 
 
42
from bzrlib.lazy_import import lazy_import
 
43
lazy_import(globals(), """
 
44
from bisect import bisect_left
 
45
import collections
 
46
from copy import deepcopy
 
47
import errno
 
48
import itertools
 
49
import operator
 
50
import stat
 
51
from time import time
 
52
import warnings
 
53
 
 
54
import bzrlib
 
55
from bzrlib import (
 
56
    branch,
 
57
    bzrdir,
 
58
    conflicts as _mod_conflicts,
 
59
    dirstate,
 
60
    errors,
 
61
    generate_ids,
 
62
    globbing,
 
63
    hashcache,
 
64
    ignores,
 
65
    merge,
 
66
    osutils,
 
67
    revisiontree,
 
68
    repository,
 
69
    textui,
 
70
    transform,
 
71
    urlutils,
 
72
    xml5,
 
73
    xml6,
 
74
    xml7,
 
75
    )
 
76
import bzrlib.branch
 
77
from bzrlib.transport import get_transport
 
78
import bzrlib.ui
 
79
from bzrlib.workingtree_4 import WorkingTreeFormat4
 
80
""")
 
81
 
 
82
from bzrlib import symbol_versioning
 
83
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
84
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, TreeReference
 
85
from bzrlib.lockable_files import LockableFiles, TransportLock
 
86
from bzrlib.lockdir import LockDir
 
87
import bzrlib.mutabletree
 
88
from bzrlib.mutabletree import needs_tree_write_lock
 
89
from bzrlib.osutils import (
 
90
    compact_date,
 
91
    file_kind,
 
92
    isdir,
 
93
    normpath,
 
94
    pathjoin,
 
95
    rand_chars,
 
96
    realpath,
 
97
    safe_unicode,
 
98
    splitpath,
 
99
    supports_executable,
 
100
    )
 
101
from bzrlib.trace import mutter, note
 
102
from bzrlib.transport.local import LocalTransport
 
103
from bzrlib.progress import DummyProgress, ProgressPhase
 
104
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
 
105
from bzrlib.rio import RioReader, rio_file, Stanza
 
106
from bzrlib.symbol_versioning import (deprecated_passed,
 
107
        deprecated_method,
 
108
        deprecated_function,
 
109
        DEPRECATED_PARAMETER,
 
110
        zero_eight,
 
111
        zero_eleven,
 
112
        zero_thirteen,
 
113
        )
 
114
 
 
115
 
 
116
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
 
117
CONFLICT_HEADER_1 = "BZR conflict list format 1"
 
118
 
 
119
 
 
120
@deprecated_function(zero_thirteen)
 
121
def gen_file_id(name):
 
122
    """Return new file id for the basename 'name'.
 
123
 
 
124
    Use bzrlib.generate_ids.gen_file_id() instead
 
125
    """
 
126
    return generate_ids.gen_file_id(name)
 
127
 
 
128
 
 
129
@deprecated_function(zero_thirteen)
 
130
def gen_root_id():
 
131
    """Return a new tree-root file id.
 
132
 
 
133
    This has been deprecated in favor of bzrlib.generate_ids.gen_root_id()
 
134
    """
 
135
    return generate_ids.gen_root_id()
 
136
 
 
137
 
 
138
class TreeEntry(object):
 
139
    """An entry that implements the minimum interface used by commands.
 
140
 
 
141
    This needs further inspection, it may be better to have 
 
142
    InventoryEntries without ids - though that seems wrong. For now,
 
143
    this is a parallel hierarchy to InventoryEntry, and needs to become
 
144
    one of several things: decorates to that hierarchy, children of, or
 
145
    parents of it.
 
146
    Another note is that these objects are currently only used when there is
 
147
    no InventoryEntry available - i.e. for unversioned objects.
 
148
    Perhaps they should be UnversionedEntry et al. ? - RBC 20051003
 
149
    """
 
150
 
 
151
    def __eq__(self, other):
 
152
        # yes, this us ugly, TODO: best practice __eq__ style.
 
153
        return (isinstance(other, TreeEntry)
 
154
                and other.__class__ == self.__class__)
 
155
 
 
156
    def kind_character(self):
 
157
        return "???"
 
158
 
 
159
 
 
160
class TreeDirectory(TreeEntry):
 
161
    """See TreeEntry. This is a directory in a working tree."""
 
162
 
 
163
    def __eq__(self, other):
 
164
        return (isinstance(other, TreeDirectory)
 
165
                and other.__class__ == self.__class__)
 
166
 
 
167
    def kind_character(self):
 
168
        return "/"
 
169
 
 
170
 
 
171
class TreeFile(TreeEntry):
 
172
    """See TreeEntry. This is a regular file in a working tree."""
 
173
 
 
174
    def __eq__(self, other):
 
175
        return (isinstance(other, TreeFile)
 
176
                and other.__class__ == self.__class__)
 
177
 
 
178
    def kind_character(self):
 
179
        return ''
 
180
 
 
181
 
 
182
class TreeLink(TreeEntry):
 
183
    """See TreeEntry. This is a symlink in a working tree."""
 
184
 
 
185
    def __eq__(self, other):
 
186
        return (isinstance(other, TreeLink)
 
187
                and other.__class__ == self.__class__)
 
188
 
 
189
    def kind_character(self):
 
190
        return ''
 
191
 
 
192
 
 
193
class WorkingTree(bzrlib.mutabletree.MutableTree):
 
194
    """Working copy tree.
 
195
 
 
196
    The inventory is held in the `Branch` working-inventory, and the
 
197
    files are in a directory on disk.
 
198
 
 
199
    It is possible for a `WorkingTree` to have a filename which is
 
200
    not listed in the Inventory and vice versa.
 
201
    """
 
202
 
 
203
    def __init__(self, basedir='.',
 
204
                 branch=DEPRECATED_PARAMETER,
 
205
                 _inventory=None,
 
206
                 _control_files=None,
 
207
                 _internal=False,
 
208
                 _format=None,
 
209
                 _bzrdir=None):
 
210
        """Construct a WorkingTree for basedir.
 
211
 
 
212
        If the branch is not supplied, it is opened automatically.
 
213
        If the branch is supplied, it must be the branch for this basedir.
 
214
        (branch.base is not cross checked, because for remote branches that
 
215
        would be meaningless).
 
216
        """
 
217
        self._format = _format
 
218
        self.bzrdir = _bzrdir
 
219
        if not _internal:
 
220
            # not created via open etc.
 
221
            warnings.warn("WorkingTree() is deprecated as of bzr version 0.8. "
 
222
                 "Please use bzrdir.open_workingtree or WorkingTree.open().",
 
223
                 DeprecationWarning,
 
224
                 stacklevel=2)
 
225
            wt = WorkingTree.open(basedir)
 
226
            self._branch = wt.branch
 
227
            self.basedir = wt.basedir
 
228
            self._control_files = wt._control_files
 
229
            self._hashcache = wt._hashcache
 
230
            self._set_inventory(wt._inventory, dirty=False)
 
231
            self._format = wt._format
 
232
            self.bzrdir = wt.bzrdir
 
233
        assert isinstance(basedir, basestring), \
 
234
            "base directory %r is not a string" % basedir
 
235
        basedir = safe_unicode(basedir)
 
236
        mutter("opening working tree %r", basedir)
 
237
        if deprecated_passed(branch):
 
238
            if not _internal:
 
239
                warnings.warn("WorkingTree(..., branch=XXX) is deprecated"
 
240
                     " as of bzr 0.8. Please use bzrdir.open_workingtree() or"
 
241
                     " WorkingTree.open().",
 
242
                     DeprecationWarning,
 
243
                     stacklevel=2
 
244
                     )
 
245
            self._branch = branch
 
246
        else:
 
247
            self._branch = self.bzrdir.open_branch()
 
248
        self.basedir = realpath(basedir)
 
249
        # if branch is at our basedir and is a format 6 or less
 
250
        if isinstance(self._format, WorkingTreeFormat2):
 
251
            # share control object
 
252
            self._control_files = self.branch.control_files
 
253
        else:
 
254
            # assume all other formats have their own control files.
 
255
            assert isinstance(_control_files, LockableFiles), \
 
256
                    "_control_files must be a LockableFiles, not %r" \
 
257
                    % _control_files
 
258
            self._control_files = _control_files
 
259
        # update the whole cache up front and write to disk if anything changed;
 
260
        # in the future we might want to do this more selectively
 
261
        # two possible ways offer themselves : in self._unlock, write the cache
 
262
        # if needed, or, when the cache sees a change, append it to the hash
 
263
        # cache file, and have the parser take the most recent entry for a
 
264
        # given path only.
 
265
        wt_trans = self.bzrdir.get_workingtree_transport(None)
 
266
        cache_filename = wt_trans.local_abspath('stat-cache')
 
267
        self._hashcache = hashcache.HashCache(basedir, cache_filename,
 
268
                                              self._control_files._file_mode)
 
269
        hc = self._hashcache
 
270
        hc.read()
 
271
        # is this scan needed ? it makes things kinda slow.
 
272
        #hc.scan()
 
273
 
 
274
        if hc.needs_write:
 
275
            mutter("write hc")
 
276
            hc.write()
 
277
 
 
278
        if _inventory is None:
 
279
            self._inventory_is_modified = False
 
280
            self.read_working_inventory()
 
281
        else:
 
282
            # the caller of __init__ has provided an inventory,
 
283
            # we assume they know what they are doing - as its only
 
284
            # the Format factory and creation methods that are
 
285
            # permitted to do this.
 
286
            self._set_inventory(_inventory, dirty=False)
 
287
 
 
288
    branch = property(
 
289
        fget=lambda self: self._branch,
 
290
        doc="""The branch this WorkingTree is connected to.
 
291
 
 
292
            This cannot be set - it is reflective of the actual disk structure
 
293
            the working tree has been constructed from.
 
294
            """)
 
295
 
 
296
    def break_lock(self):
 
297
        """Break a lock if one is present from another instance.
 
298
 
 
299
        Uses the ui factory to ask for confirmation if the lock may be from
 
300
        an active process.
 
301
 
 
302
        This will probe the repository for its lock as well.
 
303
        """
 
304
        self._control_files.break_lock()
 
305
        self.branch.break_lock()
 
306
 
 
307
    def requires_rich_root(self):
 
308
        return self._format.requires_rich_root
 
309
 
 
310
    def supports_tree_reference(self):
 
311
        return getattr(self._format, 'supports_tree_reference', False)
 
312
 
 
313
    def _set_inventory(self, inv, dirty):
 
314
        """Set the internal cached inventory.
 
315
 
 
316
        :param inv: The inventory to set.
 
317
        :param dirty: A boolean indicating whether the inventory is the same
 
318
            logical inventory as whats on disk. If True the inventory is not
 
319
            the same and should be written to disk or data will be lost, if
 
320
            False then the inventory is the same as that on disk and any
 
321
            serialisation would be unneeded overhead.
 
322
        """
 
323
        assert inv.root is not None
 
324
        self._inventory = inv
 
325
        self._inventory_is_modified = dirty
 
326
 
 
327
    @staticmethod
 
328
    def open(path=None, _unsupported=False):
 
329
        """Open an existing working tree at path.
 
330
 
 
331
        """
 
332
        if path is None:
 
333
            path = os.path.getcwdu()
 
334
        control = bzrdir.BzrDir.open(path, _unsupported)
 
335
        return control.open_workingtree(_unsupported)
 
336
        
 
337
    @staticmethod
 
338
    def open_containing(path=None):
 
339
        """Open an existing working tree which has its root about path.
 
340
        
 
341
        This probes for a working tree at path and searches upwards from there.
 
342
 
 
343
        Basically we keep looking up until we find the control directory or
 
344
        run into /.  If there isn't one, raises NotBranchError.
 
345
        TODO: give this a new exception.
 
346
        If there is one, it is returned, along with the unused portion of path.
 
347
 
 
348
        :return: The WorkingTree that contains 'path', and the rest of path
 
349
        """
 
350
        if path is None:
 
351
            path = osutils.getcwd()
 
352
        control, relpath = bzrdir.BzrDir.open_containing(path)
 
353
 
 
354
        return control.open_workingtree(), relpath
 
355
 
 
356
    @staticmethod
 
357
    def open_downlevel(path=None):
 
358
        """Open an unsupported working tree.
 
359
 
 
360
        Only intended for advanced situations like upgrading part of a bzrdir.
 
361
        """
 
362
        return WorkingTree.open(path, _unsupported=True)
 
363
 
 
364
    def __iter__(self):
 
365
        """Iterate through file_ids for this tree.
 
366
 
 
367
        file_ids are in a WorkingTree if they are in the working inventory
 
368
        and the working file exists.
 
369
        """
 
370
        inv = self._inventory
 
371
        for path, ie in inv.iter_entries():
 
372
            if osutils.lexists(self.abspath(path)):
 
373
                yield ie.file_id
 
374
 
 
375
    def __repr__(self):
 
376
        return "<%s of %s>" % (self.__class__.__name__,
 
377
                               getattr(self, 'basedir', None))
 
378
 
 
379
    def abspath(self, filename):
 
380
        return pathjoin(self.basedir, filename)
 
381
    
 
382
    def basis_tree(self):
 
383
        """Return RevisionTree for the current last revision.
 
384
        
 
385
        If the left most parent is a ghost then the returned tree will be an
 
386
        empty tree - one obtained by calling repository.revision_tree(None).
 
387
        """
 
388
        try:
 
389
            revision_id = self.get_parent_ids()[0]
 
390
        except IndexError:
 
391
            # no parents, return an empty revision tree.
 
392
            # in the future this should return the tree for
 
393
            # 'empty:' - the implicit root empty tree.
 
394
            return self.branch.repository.revision_tree(None)
 
395
        try:
 
396
            return self.revision_tree(revision_id)
 
397
        except errors.NoSuchRevision:
 
398
            pass
 
399
        # No cached copy available, retrieve from the repository.
 
400
        # FIXME? RBC 20060403 should we cache the inventory locally
 
401
        # at this point ?
 
402
        try:
 
403
            return self.branch.repository.revision_tree(revision_id)
 
404
        except errors.RevisionNotPresent:
 
405
            # the basis tree *may* be a ghost or a low level error may have
 
406
            # occured. If the revision is present, its a problem, if its not
 
407
            # its a ghost.
 
408
            if self.branch.repository.has_revision(revision_id):
 
409
                raise
 
410
            # the basis tree is a ghost so return an empty tree.
 
411
            return self.branch.repository.revision_tree(None)
 
412
 
 
413
    @staticmethod
 
414
    @deprecated_method(zero_eight)
 
415
    def create(branch, directory):
 
416
        """Create a workingtree for branch at directory.
 
417
 
 
418
        If existing_directory already exists it must have a .bzr directory.
 
419
        If it does not exist, it will be created.
 
420
 
 
421
        This returns a new WorkingTree object for the new checkout.
 
422
 
 
423
        TODO FIXME RBC 20060124 when we have checkout formats in place this
 
424
        should accept an optional revisionid to checkout [and reject this if
 
425
        checking out into the same dir as a pre-checkout-aware branch format.]
 
426
 
 
427
        XXX: When BzrDir is present, these should be created through that 
 
428
        interface instead.
 
429
        """
 
430
        warnings.warn('delete WorkingTree.create', stacklevel=3)
 
431
        transport = get_transport(directory)
 
432
        if branch.bzrdir.root_transport.base == transport.base:
 
433
            # same dir 
 
434
            return branch.bzrdir.create_workingtree()
 
435
        # different directory, 
 
436
        # create a branch reference
 
437
        # and now a working tree.
 
438
        raise NotImplementedError
 
439
 
 
440
    @staticmethod
 
441
    @deprecated_method(zero_eight)
 
442
    def create_standalone(directory):
 
443
        """Create a checkout and a branch and a repo at directory.
 
444
 
 
445
        Directory must exist and be empty.
 
446
 
 
447
        please use BzrDir.create_standalone_workingtree
 
448
        """
 
449
        return bzrdir.BzrDir.create_standalone_workingtree(directory)
 
450
 
 
451
    def relpath(self, path):
 
452
        """Return the local path portion from a given path.
 
453
        
 
454
        The path may be absolute or relative. If its a relative path it is 
 
455
        interpreted relative to the python current working directory.
 
456
        """
 
457
        return osutils.relpath(self.basedir, path)
 
458
 
 
459
    def has_filename(self, filename):
 
460
        return osutils.lexists(self.abspath(filename))
 
461
 
 
462
    def get_file(self, file_id):
 
463
        file_id = osutils.safe_file_id(file_id)
 
464
        return self.get_file_byname(self.id2path(file_id))
 
465
 
 
466
    def get_file_text(self, file_id):
 
467
        file_id = osutils.safe_file_id(file_id)
 
468
        return self.get_file(file_id).read()
 
469
 
 
470
    def get_file_byname(self, filename):
 
471
        return file(self.abspath(filename), 'rb')
 
472
 
 
473
    @needs_read_lock
 
474
    def annotate_iter(self, file_id):
 
475
        """See Tree.annotate_iter
 
476
 
 
477
        This implementation will use the basis tree implementation if possible.
 
478
        Lines not in the basis are attributed to CURRENT_REVISION
 
479
 
 
480
        If there are pending merges, lines added by those merges will be
 
481
        incorrectly attributed to CURRENT_REVISION (but after committing, the
 
482
        attribution will be correct).
 
483
        """
 
484
        file_id = osutils.safe_file_id(file_id)
 
485
        basis = self.basis_tree()
 
486
        changes = self._iter_changes(basis, True, [file_id]).next()
 
487
        changed_content, kind = changes[2], changes[6]
 
488
        if not changed_content:
 
489
            return basis.annotate_iter(file_id)
 
490
        if kind[1] is None:
 
491
            return None
 
492
        import annotate
 
493
        if kind[0] != 'file':
 
494
            old_lines = []
 
495
        else:
 
496
            old_lines = list(basis.annotate_iter(file_id))
 
497
        old = [old_lines]
 
498
        for tree in self.branch.repository.revision_trees(
 
499
            self.get_parent_ids()[1:]):
 
500
            if file_id not in tree:
 
501
                continue
 
502
            old.append(list(tree.annotate_iter(file_id)))
 
503
        return annotate.reannotate(old, self.get_file(file_id).readlines(),
 
504
                                   CURRENT_REVISION)
 
505
 
 
506
    def get_parent_ids(self):
 
507
        """See Tree.get_parent_ids.
 
508
        
 
509
        This implementation reads the pending merges list and last_revision
 
510
        value and uses that to decide what the parents list should be.
 
511
        """
 
512
        last_rev = self._last_revision()
 
513
        if last_rev is None:
 
514
            parents = []
 
515
        else:
 
516
            parents = [last_rev]
 
517
        try:
 
518
            merges_file = self._control_files.get('pending-merges')
 
519
        except errors.NoSuchFile:
 
520
            pass
 
521
        else:
 
522
            for l in merges_file.readlines():
 
523
                revision_id = osutils.safe_revision_id(l.rstrip('\n'))
 
524
                parents.append(revision_id)
 
525
        return parents
 
526
 
 
527
    @needs_read_lock
 
528
    def get_root_id(self):
 
529
        """Return the id of this trees root"""
 
530
        return self._inventory.root.file_id
 
531
        
 
532
    def _get_store_filename(self, file_id):
 
533
        ## XXX: badly named; this is not in the store at all
 
534
        file_id = osutils.safe_file_id(file_id)
 
535
        return self.abspath(self.id2path(file_id))
 
536
 
 
537
    @needs_read_lock
 
538
    def clone(self, to_bzrdir, revision_id=None, basis=None):
 
539
        """Duplicate this working tree into to_bzr, including all state.
 
540
        
 
541
        Specifically modified files are kept as modified, but
 
542
        ignored and unknown files are discarded.
 
543
 
 
544
        If you want to make a new line of development, see bzrdir.sprout()
 
545
 
 
546
        revision
 
547
            If not None, the cloned tree will have its last revision set to 
 
548
            revision, and and difference between the source trees last revision
 
549
            and this one merged in.
 
550
 
 
551
        basis
 
552
            If not None, a closer copy of a tree which may have some files in
 
553
            common, and which file content should be preferentially copied from.
 
554
        """
 
555
        # assumes the target bzr dir format is compatible.
 
556
        result = self._format.initialize(to_bzrdir)
 
557
        self.copy_content_into(result, revision_id)
 
558
        return result
 
559
 
 
560
    @needs_read_lock
 
561
    def copy_content_into(self, tree, revision_id=None):
 
562
        """Copy the current content and user files of this tree into tree."""
 
563
        tree.set_root_id(self.get_root_id())
 
564
        if revision_id is None:
 
565
            merge.transform_tree(tree, self)
 
566
        else:
 
567
            # TODO now merge from tree.last_revision to revision (to preserve
 
568
            # user local changes)
 
569
            merge.transform_tree(tree, self)
 
570
            tree.set_parent_ids([revision_id])
 
571
 
 
572
    def id2abspath(self, file_id):
 
573
        file_id = osutils.safe_file_id(file_id)
 
574
        return self.abspath(self.id2path(file_id))
 
575
 
 
576
    def has_id(self, file_id):
 
577
        # files that have been deleted are excluded
 
578
        file_id = osutils.safe_file_id(file_id)
 
579
        inv = self.inventory
 
580
        if not inv.has_id(file_id):
 
581
            return False
 
582
        path = inv.id2path(file_id)
 
583
        return osutils.lexists(self.abspath(path))
 
584
 
 
585
    def has_or_had_id(self, file_id):
 
586
        file_id = osutils.safe_file_id(file_id)
 
587
        if file_id == self.inventory.root.file_id:
 
588
            return True
 
589
        return self.inventory.has_id(file_id)
 
590
 
 
591
    __contains__ = has_id
 
592
 
 
593
    def get_file_size(self, file_id):
 
594
        file_id = osutils.safe_file_id(file_id)
 
595
        return os.path.getsize(self.id2abspath(file_id))
 
596
 
 
597
    @needs_read_lock
 
598
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
599
        file_id = osutils.safe_file_id(file_id)
 
600
        if not path:
 
601
            path = self._inventory.id2path(file_id)
 
602
        return self._hashcache.get_sha1(path, stat_value)
 
603
 
 
604
    def get_file_mtime(self, file_id, path=None):
 
605
        file_id = osutils.safe_file_id(file_id)
 
606
        if not path:
 
607
            path = self._inventory.id2path(file_id)
 
608
        return os.lstat(self.abspath(path)).st_mtime
 
609
 
 
610
    if not supports_executable():
 
611
        def is_executable(self, file_id, path=None):
 
612
            file_id = osutils.safe_file_id(file_id)
 
613
            return self._inventory[file_id].executable
 
614
    else:
 
615
        def is_executable(self, file_id, path=None):
 
616
            if not path:
 
617
                file_id = osutils.safe_file_id(file_id)
 
618
                path = self.id2path(file_id)
 
619
            mode = os.lstat(self.abspath(path)).st_mode
 
620
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
621
 
 
622
    @needs_write_lock
 
623
    def _add(self, files, ids, kinds):
 
624
        """See MutableTree._add."""
 
625
        # TODO: Re-adding a file that is removed in the working copy
 
626
        # should probably put it back with the previous ID.
 
627
        # the read and write working inventory should not occur in this 
 
628
        # function - they should be part of lock_write and unlock.
 
629
        inv = self.read_working_inventory()
 
630
        for f, file_id, kind in zip(files, ids, kinds):
 
631
            assert kind is not None
 
632
            if file_id is None:
 
633
                inv.add_path(f, kind=kind)
 
634
            else:
 
635
                file_id = osutils.safe_file_id(file_id)
 
636
                inv.add_path(f, kind=kind, file_id=file_id)
 
637
        self._write_inventory(inv)
 
638
 
 
639
    def add_reference(self, sub_tree):
 
640
        """Add a TreeReference to the tree, pointing at sub_tree"""
 
641
        raise errors.UnsupportedOperation(self.add_reference, self)
 
642
 
 
643
    @needs_tree_write_lock
 
644
    def _gather_kinds(self, files, kinds):
 
645
        """See MutableTree._gather_kinds."""
 
646
        for pos, f in enumerate(files):
 
647
            if kinds[pos] is None:
 
648
                fullpath = normpath(self.abspath(f))
 
649
                try:
 
650
                    kinds[pos] = file_kind(fullpath)
 
651
                except OSError, e:
 
652
                    if e.errno == errno.ENOENT:
 
653
                        raise errors.NoSuchFile(fullpath)
 
654
 
 
655
    @needs_write_lock
 
656
    def add_parent_tree_id(self, revision_id, allow_leftmost_as_ghost=False):
 
657
        """Add revision_id as a parent.
 
658
 
 
659
        This is equivalent to retrieving the current list of parent ids
 
660
        and setting the list to its value plus revision_id.
 
661
 
 
662
        :param revision_id: The revision id to add to the parent list. It may
 
663
        be a ghost revision as long as its not the first parent to be added,
 
664
        or the allow_leftmost_as_ghost parameter is set True.
 
665
        :param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
 
666
        """
 
667
        parents = self.get_parent_ids() + [revision_id]
 
668
        self.set_parent_ids(parents, allow_leftmost_as_ghost=len(parents) > 1
 
669
            or allow_leftmost_as_ghost)
 
670
 
 
671
    @needs_tree_write_lock
 
672
    def add_parent_tree(self, parent_tuple, allow_leftmost_as_ghost=False):
 
673
        """Add revision_id, tree tuple as a parent.
 
674
 
 
675
        This is equivalent to retrieving the current list of parent trees
 
676
        and setting the list to its value plus parent_tuple. See also
 
677
        add_parent_tree_id - if you only have a parent id available it will be
 
678
        simpler to use that api. If you have the parent already available, using
 
679
        this api is preferred.
 
680
 
 
681
        :param parent_tuple: The (revision id, tree) to add to the parent list.
 
682
            If the revision_id is a ghost, pass None for the tree.
 
683
        :param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
 
684
        """
 
685
        parent_ids = self.get_parent_ids() + [parent_tuple[0]]
 
686
        if len(parent_ids) > 1:
 
687
            # the leftmost may have already been a ghost, preserve that if it
 
688
            # was.
 
689
            allow_leftmost_as_ghost = True
 
690
        self.set_parent_ids(parent_ids,
 
691
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
692
 
 
693
    @needs_tree_write_lock
 
694
    def add_pending_merge(self, *revision_ids):
 
695
        # TODO: Perhaps should check at this point that the
 
696
        # history of the revision is actually present?
 
697
        parents = self.get_parent_ids()
 
698
        updated = False
 
699
        for rev_id in revision_ids:
 
700
            if rev_id in parents:
 
701
                continue
 
702
            parents.append(rev_id)
 
703
            updated = True
 
704
        if updated:
 
705
            self.set_parent_ids(parents, allow_leftmost_as_ghost=True)
 
706
 
 
707
    @deprecated_method(zero_eleven)
 
708
    @needs_read_lock
 
709
    def pending_merges(self):
 
710
        """Return a list of pending merges.
 
711
 
 
712
        These are revisions that have been merged into the working
 
713
        directory but not yet committed.
 
714
 
 
715
        As of 0.11 this is deprecated. Please see WorkingTree.get_parent_ids()
 
716
        instead - which is available on all tree objects.
 
717
        """
 
718
        return self.get_parent_ids()[1:]
 
719
 
 
720
    def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):
 
721
        """Common ghost checking functionality from set_parent_*.
 
722
 
 
723
        This checks that the left hand-parent exists if there are any
 
724
        revisions present.
 
725
        """
 
726
        if len(revision_ids) > 0:
 
727
            leftmost_id = revision_ids[0]
 
728
            if (not allow_leftmost_as_ghost and not
 
729
                self.branch.repository.has_revision(leftmost_id)):
 
730
                raise errors.GhostRevisionUnusableHere(leftmost_id)
 
731
 
 
732
    def _set_merges_from_parent_ids(self, parent_ids):
 
733
        merges = parent_ids[1:]
 
734
        self._control_files.put_bytes('pending-merges', '\n'.join(merges))
 
735
 
 
736
    @needs_tree_write_lock
 
737
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
 
738
        """Set the parent ids to revision_ids.
 
739
        
 
740
        See also set_parent_trees. This api will try to retrieve the tree data
 
741
        for each element of revision_ids from the trees repository. If you have
 
742
        tree data already available, it is more efficient to use
 
743
        set_parent_trees rather than set_parent_ids. set_parent_ids is however
 
744
        an easier API to use.
 
745
 
 
746
        :param revision_ids: The revision_ids to set as the parent ids of this
 
747
            working tree. Any of these may be ghosts.
 
748
        """
 
749
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
 
750
        self._check_parents_for_ghosts(revision_ids,
 
751
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
752
 
 
753
        if len(revision_ids) > 0:
 
754
            self.set_last_revision(revision_ids[0])
 
755
        else:
 
756
            self.set_last_revision(None)
 
757
 
 
758
        self._set_merges_from_parent_ids(revision_ids)
 
759
 
 
760
    @needs_tree_write_lock
 
761
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
 
762
        """See MutableTree.set_parent_trees."""
 
763
        parent_ids = [osutils.safe_revision_id(rev) for (rev, tree) in parents_list]
 
764
 
 
765
        self._check_parents_for_ghosts(parent_ids,
 
766
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
767
 
 
768
        if len(parent_ids) == 0:
 
769
            leftmost_parent_id = None
 
770
            leftmost_parent_tree = None
 
771
        else:
 
772
            leftmost_parent_id, leftmost_parent_tree = parents_list[0]
 
773
 
 
774
        if self._change_last_revision(leftmost_parent_id):
 
775
            if leftmost_parent_tree is None:
 
776
                # If we don't have a tree, fall back to reading the
 
777
                # parent tree from the repository.
 
778
                self._cache_basis_inventory(leftmost_parent_id)
 
779
            else:
 
780
                inv = leftmost_parent_tree.inventory
 
781
                xml = self._create_basis_xml_from_inventory(
 
782
                                        leftmost_parent_id, inv)
 
783
                self._write_basis_inventory(xml)
 
784
        self._set_merges_from_parent_ids(parent_ids)
 
785
 
 
786
    @needs_tree_write_lock
 
787
    def set_pending_merges(self, rev_list):
 
788
        parents = self.get_parent_ids()
 
789
        leftmost = parents[:1]
 
790
        new_parents = leftmost + rev_list
 
791
        self.set_parent_ids(new_parents)
 
792
 
 
793
    @needs_tree_write_lock
 
794
    def set_merge_modified(self, modified_hashes):
 
795
        def iter_stanzas():
 
796
            for file_id, hash in modified_hashes.iteritems():
 
797
                yield Stanza(file_id=file_id.decode('utf8'), hash=hash)
 
798
        self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
 
799
 
 
800
    @needs_tree_write_lock
 
801
    def _put_rio(self, filename, stanzas, header):
 
802
        my_file = rio_file(stanzas, header)
 
803
        self._control_files.put(filename, my_file)
 
804
 
 
805
    @needs_write_lock # because merge pulls data into the branch.
 
806
    def merge_from_branch(self, branch, to_revision=None):
 
807
        """Merge from a branch into this working tree.
 
808
 
 
809
        :param branch: The branch to merge from.
 
810
        :param to_revision: If non-None, the merge will merge to to_revision,
 
811
            but not beyond it. to_revision does not need to be in the history
 
812
            of the branch when it is supplied. If None, to_revision defaults to
 
813
            branch.last_revision().
 
814
        """
 
815
        from bzrlib.merge import Merger, Merge3Merger
 
816
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
817
        try:
 
818
            merger = Merger(self.branch, this_tree=self, pb=pb)
 
819
            merger.pp = ProgressPhase("Merge phase", 5, pb)
 
820
            merger.pp.next_phase()
 
821
            # check that there are no
 
822
            # local alterations
 
823
            merger.check_basis(check_clean=True, require_commits=False)
 
824
            if to_revision is None:
 
825
                to_revision = branch.last_revision()
 
826
            else:
 
827
                to_revision = osutils.safe_revision_id(to_revision)
 
828
            merger.other_rev_id = to_revision
 
829
            if merger.other_rev_id is None:
 
830
                raise error.NoCommits(branch)
 
831
            self.branch.fetch(branch, last_revision=merger.other_rev_id)
 
832
            merger.other_basis = merger.other_rev_id
 
833
            merger.other_tree = self.branch.repository.revision_tree(
 
834
                merger.other_rev_id)
 
835
            merger.other_branch = branch
 
836
            merger.pp.next_phase()
 
837
            merger.find_base()
 
838
            if merger.base_rev_id == merger.other_rev_id:
 
839
                raise errors.PointlessMerge
 
840
            merger.backup_files = False
 
841
            merger.merge_type = Merge3Merger
 
842
            merger.set_interesting_files(None)
 
843
            merger.show_base = False
 
844
            merger.reprocess = False
 
845
            conflicts = merger.do_merge()
 
846
            merger.set_pending()
 
847
        finally:
 
848
            pb.finished()
 
849
        return conflicts
 
850
 
 
851
    @needs_write_lock
 
852
    def subsume(self, other_tree):
 
853
        def add_children(inventory, entry):
 
854
            for child_entry in entry.children.values():
 
855
                inventory._byid[child_entry.file_id] = child_entry
 
856
                if child_entry.kind == 'directory':
 
857
                    add_children(inventory, child_entry)
 
858
        if other_tree.get_root_id() == self.get_root_id():
 
859
            raise errors.BadSubsumeSource(self, other_tree, 
 
860
                                          'Trees have the same root')
 
861
        try:
 
862
            other_tree_path = self.relpath(other_tree.basedir)
 
863
        except errors.PathNotChild:
 
864
            raise errors.BadSubsumeSource(self, other_tree, 
 
865
                'Tree is not contained by the other')
 
866
        new_root_parent = self.path2id(osutils.dirname(other_tree_path))
 
867
        if new_root_parent is None:
 
868
            raise errors.BadSubsumeSource(self, other_tree, 
 
869
                'Parent directory is not versioned.')
 
870
        # We need to ensure that the result of a fetch will have a
 
871
        # versionedfile for the other_tree root, and only fetching into
 
872
        # RepositoryKnit2 guarantees that.
 
873
        if not self.branch.repository.supports_rich_root():
 
874
            raise errors.SubsumeTargetNeedsUpgrade(other_tree)
 
875
        other_tree.lock_tree_write()
 
876
        try:
 
877
            for parent_id in other_tree.get_parent_ids():
 
878
                self.branch.fetch(other_tree.branch, parent_id)
 
879
                self.add_parent_tree_id(parent_id)
 
880
            other_root = other_tree.inventory.root
 
881
            other_root.parent_id = new_root_parent
 
882
            other_root.name = osutils.basename(other_tree_path)
 
883
            self.inventory.add(other_root)
 
884
            add_children(self.inventory, other_root)
 
885
            self._write_inventory(self.inventory)
 
886
        finally:
 
887
            other_tree.unlock()
 
888
        other_tree.bzrdir.destroy_workingtree_metadata()
 
889
 
 
890
    @needs_tree_write_lock
 
891
    def extract(self, file_id, format=None):
 
892
        """Extract a subtree from this tree.
 
893
        
 
894
        A new branch will be created, relative to the path for this tree.
 
895
        """
 
896
        def mkdirs(path):
 
897
            segments = osutils.splitpath(path)
 
898
            transport = self.branch.bzrdir.root_transport
 
899
            for name in segments:
 
900
                transport = transport.clone(name)
 
901
                try:
 
902
                    transport.mkdir('.')
 
903
                except errors.FileExists:
 
904
                    pass
 
905
            return transport
 
906
            
 
907
        sub_path = self.id2path(file_id)
 
908
        branch_transport = mkdirs(sub_path)
 
909
        if format is None:
 
910
            format = bzrdir.format_registry.make_bzrdir('experimental-knit2')
 
911
        try:
 
912
            branch_transport.mkdir('.')
 
913
        except errors.FileExists:
 
914
            pass
 
915
        branch_bzrdir = format.initialize_on_transport(branch_transport)
 
916
        try:
 
917
            repo = branch_bzrdir.find_repository()
 
918
        except errors.NoRepositoryPresent:
 
919
            repo = branch_bzrdir.create_repository()
 
920
            assert repo.supports_rich_root()
 
921
        else:
 
922
            if not repo.supports_rich_root():
 
923
                raise errors.RootNotRich()
 
924
        new_branch = branch_bzrdir.create_branch()
 
925
        new_branch.pull(self.branch)
 
926
        for parent_id in self.get_parent_ids():
 
927
            new_branch.fetch(self.branch, parent_id)
 
928
        tree_transport = self.bzrdir.root_transport.clone(sub_path)
 
929
        if tree_transport.base != branch_transport.base:
 
930
            tree_bzrdir = format.initialize_on_transport(tree_transport)
 
931
            branch.BranchReferenceFormat().initialize(tree_bzrdir, new_branch)
 
932
        else:
 
933
            tree_bzrdir = branch_bzrdir
 
934
        wt = tree_bzrdir.create_workingtree(NULL_REVISION)
 
935
        wt.set_parent_ids(self.get_parent_ids())
 
936
        my_inv = self.inventory
 
937
        child_inv = Inventory(root_id=None)
 
938
        new_root = my_inv[file_id]
 
939
        my_inv.remove_recursive_id(file_id)
 
940
        new_root.parent_id = None
 
941
        child_inv.add(new_root)
 
942
        self._write_inventory(my_inv)
 
943
        wt._write_inventory(child_inv)
 
944
        return wt
 
945
 
 
946
    @needs_read_lock
 
947
    def merge_modified(self):
 
948
        try:
 
949
            hashfile = self._control_files.get('merge-hashes')
 
950
        except errors.NoSuchFile:
 
951
            return {}
 
952
        merge_hashes = {}
 
953
        try:
 
954
            if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
 
955
                raise errors.MergeModifiedFormatError()
 
956
        except StopIteration:
 
957
            raise errors.MergeModifiedFormatError()
 
958
        for s in RioReader(hashfile):
 
959
            file_id = s.get("file_id")
 
960
            if file_id not in self.inventory:
 
961
                continue
 
962
            hash = s.get("hash")
 
963
            if hash == self.get_file_sha1(file_id):
 
964
                merge_hashes[file_id] = hash
 
965
        return merge_hashes
 
966
 
 
967
    @needs_write_lock
 
968
    def mkdir(self, path, file_id=None):
 
969
        """See MutableTree.mkdir()."""
 
970
        if file_id is None:
 
971
            file_id = generate_ids.gen_file_id(os.path.basename(path))
 
972
        os.mkdir(self.abspath(path))
 
973
        self.add(path, file_id, 'directory')
 
974
        return file_id
 
975
 
 
976
    def get_symlink_target(self, file_id):
 
977
        return os.readlink(self.id2abspath(file_id))
 
978
 
 
979
    def file_class(self, filename):
 
980
        if self.path2id(filename):
 
981
            return 'V'
 
982
        elif self.is_ignored(filename):
 
983
            return 'I'
 
984
        else:
 
985
            return '?'
 
986
 
 
987
    def flush(self):
 
988
        """Write the in memory inventory to disk."""
 
989
        # TODO: Maybe this should only write on dirty ?
 
990
        if self._control_files._lock_mode != 'w':
 
991
            raise errors.NotWriteLocked(self)
 
992
        sio = StringIO()
 
993
        self._serialize(self._inventory, sio)
 
994
        sio.seek(0)
 
995
        self._control_files.put('inventory', sio)
 
996
        self._inventory_is_modified = False
 
997
 
 
998
    def _serialize(self, inventory, out_file):
 
999
        xml5.serializer_v5.write_inventory(self._inventory, out_file)
 
1000
 
 
1001
    def _deserialize(selt, in_file):
 
1002
        return xml5.serializer_v5.read_inventory(in_file)
 
1003
 
 
1004
    def list_files(self, include_root=False):
 
1005
        """Recursively list all files as (path, class, kind, id, entry).
 
1006
 
 
1007
        Lists, but does not descend into unversioned directories.
 
1008
 
 
1009
        This does not include files that have been deleted in this
 
1010
        tree.
 
1011
 
 
1012
        Skips the control directory.
 
1013
        """
 
1014
        # list_files is an iterator, so @needs_read_lock doesn't work properly
 
1015
        # with it. So callers should be careful to always read_lock the tree.
 
1016
        if not self.is_locked():
 
1017
            raise errors.ObjectNotLocked(self)
 
1018
 
 
1019
        inv = self.inventory
 
1020
        if include_root is True:
 
1021
            yield ('', 'V', 'directory', inv.root.file_id, inv.root)
 
1022
        # Convert these into local objects to save lookup times
 
1023
        pathjoin = osutils.pathjoin
 
1024
        file_kind = osutils.file_kind
 
1025
 
 
1026
        # transport.base ends in a slash, we want the piece
 
1027
        # between the last two slashes
 
1028
        transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
 
1029
 
 
1030
        fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
 
1031
 
 
1032
        # directory file_id, relative path, absolute path, reverse sorted children
 
1033
        children = os.listdir(self.basedir)
 
1034
        children.sort()
 
1035
        # jam 20060527 The kernel sized tree seems equivalent whether we 
 
1036
        # use a deque and popleft to keep them sorted, or if we use a plain
 
1037
        # list and just reverse() them.
 
1038
        children = collections.deque(children)
 
1039
        stack = [(inv.root.file_id, u'', self.basedir, children)]
 
1040
        while stack:
 
1041
            from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
 
1042
 
 
1043
            while children:
 
1044
                f = children.popleft()
 
1045
                ## TODO: If we find a subdirectory with its own .bzr
 
1046
                ## directory, then that is a separate tree and we
 
1047
                ## should exclude it.
 
1048
 
 
1049
                # the bzrdir for this tree
 
1050
                if transport_base_dir == f:
 
1051
                    continue
 
1052
 
 
1053
                # we know that from_dir_relpath and from_dir_abspath never end in a slash
 
1054
                # and 'f' doesn't begin with one, we can do a string op, rather
 
1055
                # than the checks of pathjoin(), all relative paths will have an extra slash
 
1056
                # at the beginning
 
1057
                fp = from_dir_relpath + '/' + f
 
1058
 
 
1059
                # absolute path
 
1060
                fap = from_dir_abspath + '/' + f
 
1061
                
 
1062
                f_ie = inv.get_child(from_dir_id, f)
 
1063
                if f_ie:
 
1064
                    c = 'V'
 
1065
                elif self.is_ignored(fp[1:]):
 
1066
                    c = 'I'
 
1067
                else:
 
1068
                    # we may not have found this file, because of a unicode issue
 
1069
                    f_norm, can_access = osutils.normalized_filename(f)
 
1070
                    if f == f_norm or not can_access:
 
1071
                        # No change, so treat this file normally
 
1072
                        c = '?'
 
1073
                    else:
 
1074
                        # this file can be accessed by a normalized path
 
1075
                        # check again if it is versioned
 
1076
                        # these lines are repeated here for performance
 
1077
                        f = f_norm
 
1078
                        fp = from_dir_relpath + '/' + f
 
1079
                        fap = from_dir_abspath + '/' + f
 
1080
                        f_ie = inv.get_child(from_dir_id, f)
 
1081
                        if f_ie:
 
1082
                            c = 'V'
 
1083
                        elif self.is_ignored(fp[1:]):
 
1084
                            c = 'I'
 
1085
                        else:
 
1086
                            c = '?'
 
1087
 
 
1088
                fk = file_kind(fap)
 
1089
 
 
1090
                if f_ie:
 
1091
                    if f_ie.kind != fk:
 
1092
                        raise errors.BzrCheckError(
 
1093
                            "file %r entered as kind %r id %r, now of kind %r"
 
1094
                            % (fap, f_ie.kind, f_ie.file_id, fk))
 
1095
 
 
1096
                # make a last minute entry
 
1097
                if f_ie:
 
1098
                    yield fp[1:], c, fk, f_ie.file_id, f_ie
 
1099
                else:
 
1100
                    try:
 
1101
                        yield fp[1:], c, fk, None, fk_entries[fk]()
 
1102
                    except KeyError:
 
1103
                        yield fp[1:], c, fk, None, TreeEntry()
 
1104
                    continue
 
1105
                
 
1106
                if fk != 'directory':
 
1107
                    continue
 
1108
 
 
1109
                # But do this child first
 
1110
                new_children = os.listdir(fap)
 
1111
                new_children.sort()
 
1112
                new_children = collections.deque(new_children)
 
1113
                stack.append((f_ie.file_id, fp, fap, new_children))
 
1114
                # Break out of inner loop,
 
1115
                # so that we start outer loop with child
 
1116
                break
 
1117
            else:
 
1118
                # if we finished all children, pop it off the stack
 
1119
                stack.pop()
 
1120
 
 
1121
    @needs_tree_write_lock
 
1122
    def move(self, from_paths, to_dir=None, after=False, **kwargs):
 
1123
        """Rename files.
 
1124
 
 
1125
        to_dir must exist in the inventory.
 
1126
 
 
1127
        If to_dir exists and is a directory, the files are moved into
 
1128
        it, keeping their old names.  
 
1129
 
 
1130
        Note that to_dir is only the last component of the new name;
 
1131
        this doesn't change the directory.
 
1132
 
 
1133
        For each entry in from_paths the move mode will be determined
 
1134
        independently.
 
1135
 
 
1136
        The first mode moves the file in the filesystem and updates the
 
1137
        inventory. The second mode only updates the inventory without
 
1138
        touching the file on the filesystem. This is the new mode introduced
 
1139
        in version 0.15.
 
1140
 
 
1141
        move uses the second mode if 'after == True' and the target is not
 
1142
        versioned but present in the working tree.
 
1143
 
 
1144
        move uses the second mode if 'after == False' and the source is
 
1145
        versioned but no longer in the working tree, and the target is not
 
1146
        versioned but present in the working tree.
 
1147
 
 
1148
        move uses the first mode if 'after == False' and the source is
 
1149
        versioned and present in the working tree, and the target is not
 
1150
        versioned and not present in the working tree.
 
1151
 
 
1152
        Everything else results in an error.
 
1153
 
 
1154
        This returns a list of (from_path, to_path) pairs for each
 
1155
        entry that is moved.
 
1156
        """
 
1157
        rename_entries = []
 
1158
        rename_tuples = []
 
1159
 
 
1160
        # check for deprecated use of signature
 
1161
        if to_dir is None:
 
1162
            to_dir = kwargs.get('to_name', None)
 
1163
            if to_dir is None:
 
1164
                raise TypeError('You must supply a target directory')
 
1165
            else:
 
1166
                symbol_versioning.warn('The parameter to_name was deprecated'
 
1167
                                       ' in version 0.13. Use to_dir instead',
 
1168
                                       DeprecationWarning)
 
1169
 
 
1170
        # check destination directory
 
1171
        assert not isinstance(from_paths, basestring)
 
1172
        inv = self.inventory
 
1173
        to_abs = self.abspath(to_dir)
 
1174
        if not isdir(to_abs):
 
1175
            raise errors.BzrMoveFailedError('',to_dir,
 
1176
                errors.NotADirectory(to_abs))
 
1177
        if not self.has_filename(to_dir):
 
1178
            raise errors.BzrMoveFailedError('',to_dir,
 
1179
                errors.NotInWorkingDirectory(to_dir))
 
1180
        to_dir_id = inv.path2id(to_dir)
 
1181
        if to_dir_id is None:
 
1182
            raise errors.BzrMoveFailedError('',to_dir,
 
1183
                errors.NotVersionedError(path=str(to_dir)))
 
1184
 
 
1185
        to_dir_ie = inv[to_dir_id]
 
1186
        if to_dir_ie.kind != 'directory':
 
1187
            raise errors.BzrMoveFailedError('',to_dir,
 
1188
                errors.NotADirectory(to_abs))
 
1189
 
 
1190
        # create rename entries and tuples
 
1191
        for from_rel in from_paths:
 
1192
            from_tail = splitpath(from_rel)[-1]
 
1193
            from_id = inv.path2id(from_rel)
 
1194
            if from_id is None:
 
1195
                raise errors.BzrMoveFailedError(from_rel,to_dir,
 
1196
                    errors.NotVersionedError(path=str(from_rel)))
 
1197
 
 
1198
            from_entry = inv[from_id]
 
1199
            from_parent_id = from_entry.parent_id
 
1200
            to_rel = pathjoin(to_dir, from_tail)
 
1201
            rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
 
1202
                                         from_id=from_id,
 
1203
                                         from_tail=from_tail,
 
1204
                                         from_parent_id=from_parent_id,
 
1205
                                         to_rel=to_rel, to_tail=from_tail,
 
1206
                                         to_parent_id=to_dir_id)
 
1207
            rename_entries.append(rename_entry)
 
1208
            rename_tuples.append((from_rel, to_rel))
 
1209
 
 
1210
        # determine which move mode to use. checks also for movability
 
1211
        rename_entries = self._determine_mv_mode(rename_entries, after)
 
1212
 
 
1213
        original_modified = self._inventory_is_modified
 
1214
        try:
 
1215
            if len(from_paths):
 
1216
                self._inventory_is_modified = True
 
1217
            self._move(rename_entries)
 
1218
        except:
 
1219
            # restore the inventory on error
 
1220
            self._inventory_is_modified = original_modified
 
1221
            raise
 
1222
        self._write_inventory(inv)
 
1223
        return rename_tuples
 
1224
 
 
1225
    def _determine_mv_mode(self, rename_entries, after=False):
 
1226
        """Determines for each from-to pair if both inventory and working tree
 
1227
        or only the inventory has to be changed.
 
1228
 
 
1229
        Also does basic plausability tests.
 
1230
        """
 
1231
        inv = self.inventory
 
1232
 
 
1233
        for rename_entry in rename_entries:
 
1234
            # store to local variables for easier reference
 
1235
            from_rel = rename_entry.from_rel
 
1236
            from_id = rename_entry.from_id
 
1237
            to_rel = rename_entry.to_rel
 
1238
            to_id = inv.path2id(to_rel)
 
1239
            only_change_inv = False
 
1240
 
 
1241
            # check the inventory for source and destination
 
1242
            if from_id is None:
 
1243
                raise errors.BzrMoveFailedError(from_rel,to_rel,
 
1244
                    errors.NotVersionedError(path=str(from_rel)))
 
1245
            if to_id is not None:
 
1246
                raise errors.BzrMoveFailedError(from_rel,to_rel,
 
1247
                    errors.AlreadyVersionedError(path=str(to_rel)))
 
1248
 
 
1249
            # try to determine the mode for rename (only change inv or change
 
1250
            # inv and file system)
 
1251
            if after:
 
1252
                if not self.has_filename(to_rel):
 
1253
                    raise errors.BzrMoveFailedError(from_id,to_rel,
 
1254
                        errors.NoSuchFile(path=str(to_rel),
 
1255
                        extra="New file has not been created yet"))
 
1256
                only_change_inv = True
 
1257
            elif not self.has_filename(from_rel) and self.has_filename(to_rel):
 
1258
                only_change_inv = True
 
1259
            elif self.has_filename(from_rel) and not self.has_filename(to_rel):
 
1260
                only_change_inv = False
 
1261
            else:
 
1262
                # something is wrong, so lets determine what exactly
 
1263
                if not self.has_filename(from_rel) and \
 
1264
                   not self.has_filename(to_rel):
 
1265
                    raise errors.BzrRenameFailedError(from_rel,to_rel,
 
1266
                        errors.PathsDoNotExist(paths=(str(from_rel),
 
1267
                        str(to_rel))))
 
1268
                else:
 
1269
                    raise errors.RenameFailedFilesExist(from_rel, to_rel,
 
1270
                        extra="(Use --after to update the Bazaar id)")
 
1271
            rename_entry.only_change_inv = only_change_inv
 
1272
        return rename_entries
 
1273
 
 
1274
    def _move(self, rename_entries):
 
1275
        """Moves a list of files.
 
1276
 
 
1277
        Depending on the value of the flag 'only_change_inv', the
 
1278
        file will be moved on the file system or not.
 
1279
        """
 
1280
        inv = self.inventory
 
1281
        moved = []
 
1282
 
 
1283
        for entry in rename_entries:
 
1284
            try:
 
1285
                self._move_entry(entry)
 
1286
            except:
 
1287
                self._rollback_move(moved)
 
1288
                raise
 
1289
            moved.append(entry)
 
1290
 
 
1291
    def _rollback_move(self, moved):
 
1292
        """Try to rollback a previous move in case of an filesystem error."""
 
1293
        inv = self.inventory
 
1294
        for entry in moved:
 
1295
            try:
 
1296
                self._move_entry(_RenameEntry(entry.to_rel, entry.from_id,
 
1297
                    entry.to_tail, entry.to_parent_id, entry.from_rel,
 
1298
                    entry.from_tail, entry.from_parent_id,
 
1299
                    entry.only_change_inv))
 
1300
            except errors.BzrMoveFailedError, e:
 
1301
                raise errors.BzrMoveFailedError( '', '', "Rollback failed."
 
1302
                        " The working tree is in an inconsistent state."
 
1303
                        " Please consider doing a 'bzr revert'."
 
1304
                        " Error message is: %s" % e)
 
1305
 
 
1306
    def _move_entry(self, entry):
 
1307
        inv = self.inventory
 
1308
        from_rel_abs = self.abspath(entry.from_rel)
 
1309
        to_rel_abs = self.abspath(entry.to_rel)
 
1310
        if from_rel_abs == to_rel_abs:
 
1311
            raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
 
1312
                "Source and target are identical.")
 
1313
 
 
1314
        if not entry.only_change_inv:
 
1315
            try:
 
1316
                osutils.rename(from_rel_abs, to_rel_abs)
 
1317
            except OSError, e:
 
1318
                raise errors.BzrMoveFailedError(entry.from_rel,
 
1319
                    entry.to_rel, e[1])
 
1320
        inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
 
1321
 
 
1322
    @needs_tree_write_lock
 
1323
    def rename_one(self, from_rel, to_rel, after=False):
 
1324
        """Rename one file.
 
1325
 
 
1326
        This can change the directory or the filename or both.
 
1327
 
 
1328
        rename_one has several 'modes' to work. First, it can rename a physical
 
1329
        file and change the file_id. That is the normal mode. Second, it can
 
1330
        only change the file_id without touching any physical file. This is
 
1331
        the new mode introduced in version 0.15.
 
1332
 
 
1333
        rename_one uses the second mode if 'after == True' and 'to_rel' is not
 
1334
        versioned but present in the working tree.
 
1335
 
 
1336
        rename_one uses the second mode if 'after == False' and 'from_rel' is
 
1337
        versioned but no longer in the working tree, and 'to_rel' is not
 
1338
        versioned but present in the working tree.
 
1339
 
 
1340
        rename_one uses the first mode if 'after == False' and 'from_rel' is
 
1341
        versioned and present in the working tree, and 'to_rel' is not
 
1342
        versioned and not present in the working tree.
 
1343
 
 
1344
        Everything else results in an error.
 
1345
        """
 
1346
        inv = self.inventory
 
1347
        rename_entries = []
 
1348
 
 
1349
        # create rename entries and tuples
 
1350
        from_tail = splitpath(from_rel)[-1]
 
1351
        from_id = inv.path2id(from_rel)
 
1352
        if from_id is None:
 
1353
            raise errors.BzrRenameFailedError(from_rel,to_rel,
 
1354
                errors.NotVersionedError(path=str(from_rel)))
 
1355
        from_entry = inv[from_id]
 
1356
        from_parent_id = from_entry.parent_id
 
1357
        to_dir, to_tail = os.path.split(to_rel)
 
1358
        to_dir_id = inv.path2id(to_dir)
 
1359
        rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
 
1360
                                     from_id=from_id,
 
1361
                                     from_tail=from_tail,
 
1362
                                     from_parent_id=from_parent_id,
 
1363
                                     to_rel=to_rel, to_tail=to_tail,
 
1364
                                     to_parent_id=to_dir_id)
 
1365
        rename_entries.append(rename_entry)
 
1366
 
 
1367
        # determine which move mode to use. checks also for movability
 
1368
        rename_entries = self._determine_mv_mode(rename_entries, after)
 
1369
 
 
1370
        # check if the target changed directory and if the target directory is
 
1371
        # versioned
 
1372
        if to_dir_id is None:
 
1373
            raise errors.BzrMoveFailedError(from_rel,to_rel,
 
1374
                errors.NotVersionedError(path=str(to_dir)))
 
1375
 
 
1376
        # all checks done. now we can continue with our actual work
 
1377
        mutter('rename_one:\n'
 
1378
               '  from_id   {%s}\n'
 
1379
               '  from_rel: %r\n'
 
1380
               '  to_rel:   %r\n'
 
1381
               '  to_dir    %r\n'
 
1382
               '  to_dir_id {%s}\n',
 
1383
               from_id, from_rel, to_rel, to_dir, to_dir_id)
 
1384
 
 
1385
        self._move(rename_entries)
 
1386
        self._write_inventory(inv)
 
1387
 
 
1388
    class _RenameEntry(object):
 
1389
        def __init__(self, from_rel, from_id, from_tail, from_parent_id,
 
1390
                     to_rel, to_tail, to_parent_id, only_change_inv=False):
 
1391
            self.from_rel = from_rel
 
1392
            self.from_id = from_id
 
1393
            self.from_tail = from_tail
 
1394
            self.from_parent_id = from_parent_id
 
1395
            self.to_rel = to_rel
 
1396
            self.to_tail = to_tail
 
1397
            self.to_parent_id = to_parent_id
 
1398
            self.only_change_inv = only_change_inv
 
1399
 
 
1400
    @needs_read_lock
 
1401
    def unknowns(self):
 
1402
        """Return all unknown files.
 
1403
 
 
1404
        These are files in the working directory that are not versioned or
 
1405
        control files or ignored.
 
1406
        """
 
1407
        # force the extras method to be fully executed before returning, to 
 
1408
        # prevent race conditions with the lock
 
1409
        return iter(
 
1410
            [subp for subp in self.extras() if not self.is_ignored(subp)])
 
1411
    
 
1412
    @needs_tree_write_lock
 
1413
    def unversion(self, file_ids):
 
1414
        """Remove the file ids in file_ids from the current versioned set.
 
1415
 
 
1416
        When a file_id is unversioned, all of its children are automatically
 
1417
        unversioned.
 
1418
 
 
1419
        :param file_ids: The file ids to stop versioning.
 
1420
        :raises: NoSuchId if any fileid is not currently versioned.
 
1421
        """
 
1422
        for file_id in file_ids:
 
1423
            file_id = osutils.safe_file_id(file_id)
 
1424
            if self._inventory.has_id(file_id):
 
1425
                self._inventory.remove_recursive_id(file_id)
 
1426
            else:
 
1427
                raise errors.NoSuchId(self, file_id)
 
1428
        if len(file_ids):
 
1429
            # in the future this should just set a dirty bit to wait for the 
 
1430
            # final unlock. However, until all methods of workingtree start
 
1431
            # with the current in -memory inventory rather than triggering 
 
1432
            # a read, it is more complex - we need to teach read_inventory
 
1433
            # to know when to read, and when to not read first... and possibly
 
1434
            # to save first when the in memory one may be corrupted.
 
1435
            # so for now, we just only write it if it is indeed dirty.
 
1436
            # - RBC 20060907
 
1437
            self._write_inventory(self._inventory)
 
1438
    
 
1439
    @deprecated_method(zero_eight)
 
1440
    def iter_conflicts(self):
 
1441
        """List all files in the tree that have text or content conflicts.
 
1442
        DEPRECATED.  Use conflicts instead."""
 
1443
        return self._iter_conflicts()
 
1444
 
 
1445
    def _iter_conflicts(self):
 
1446
        conflicted = set()
 
1447
        for info in self.list_files():
 
1448
            path = info[0]
 
1449
            stem = get_conflicted_stem(path)
 
1450
            if stem is None:
 
1451
                continue
 
1452
            if stem not in conflicted:
 
1453
                conflicted.add(stem)
 
1454
                yield stem
 
1455
 
 
1456
    @needs_write_lock
 
1457
    def pull(self, source, overwrite=False, stop_revision=None,
 
1458
             change_reporter=None):
 
1459
        top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1460
        source.lock_read()
 
1461
        try:
 
1462
            pp = ProgressPhase("Pull phase", 2, top_pb)
 
1463
            pp.next_phase()
 
1464
            old_revision_info = self.branch.last_revision_info()
 
1465
            basis_tree = self.basis_tree()
 
1466
            count = self.branch.pull(source, overwrite, stop_revision)
 
1467
            new_revision_info = self.branch.last_revision_info()
 
1468
            if new_revision_info != old_revision_info:
 
1469
                pp.next_phase()
 
1470
                repository = self.branch.repository
 
1471
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1472
                basis_tree.lock_read()
 
1473
                try:
 
1474
                    new_basis_tree = self.branch.basis_tree()
 
1475
                    merge.merge_inner(
 
1476
                                self.branch,
 
1477
                                new_basis_tree,
 
1478
                                basis_tree,
 
1479
                                this_tree=self,
 
1480
                                pb=pb,
 
1481
                                change_reporter=change_reporter)
 
1482
                    if (basis_tree.inventory.root is None and
 
1483
                        new_basis_tree.inventory.root is not None):
 
1484
                        self.set_root_id(new_basis_tree.inventory.root.file_id)
 
1485
                finally:
 
1486
                    pb.finished()
 
1487
                    basis_tree.unlock()
 
1488
                # TODO - dedup parents list with things merged by pull ?
 
1489
                # reuse the revisiontree we merged against to set the new
 
1490
                # tree data.
 
1491
                parent_trees = [(self.branch.last_revision(), new_basis_tree)]
 
1492
                # we have to pull the merge trees out again, because 
 
1493
                # merge_inner has set the ids. - this corner is not yet 
 
1494
                # layered well enough to prevent double handling.
 
1495
                # XXX TODO: Fix the double handling: telling the tree about
 
1496
                # the already known parent data is wasteful.
 
1497
                merges = self.get_parent_ids()[1:]
 
1498
                parent_trees.extend([
 
1499
                    (parent, repository.revision_tree(parent)) for
 
1500
                     parent in merges])
 
1501
                self.set_parent_trees(parent_trees)
 
1502
            return count
 
1503
        finally:
 
1504
            source.unlock()
 
1505
            top_pb.finished()
 
1506
 
 
1507
    @needs_write_lock
 
1508
    def put_file_bytes_non_atomic(self, file_id, bytes):
 
1509
        """See MutableTree.put_file_bytes_non_atomic."""
 
1510
        file_id = osutils.safe_file_id(file_id)
 
1511
        stream = file(self.id2abspath(file_id), 'wb')
 
1512
        try:
 
1513
            stream.write(bytes)
 
1514
        finally:
 
1515
            stream.close()
 
1516
        # TODO: update the hashcache here ?
 
1517
 
 
1518
    def extras(self):
 
1519
        """Yield all unknown files in this WorkingTree.
 
1520
 
 
1521
        If there are any unknown directories then only the directory is
 
1522
        returned, not all its children.  But if there are unknown files
 
1523
        under a versioned subdirectory, they are returned.
 
1524
 
 
1525
        Currently returned depth-first, sorted by name within directories.
 
1526
        """
 
1527
        ## TODO: Work from given directory downwards
 
1528
        for path, dir_entry in self.inventory.directories():
 
1529
            # mutter("search for unknowns in %r", path)
 
1530
            dirabs = self.abspath(path)
 
1531
            if not isdir(dirabs):
 
1532
                # e.g. directory deleted
 
1533
                continue
 
1534
 
 
1535
            fl = []
 
1536
            for subf in os.listdir(dirabs):
 
1537
                if subf == '.bzr':
 
1538
                    continue
 
1539
                if subf not in dir_entry.children:
 
1540
                    subf_norm, can_access = osutils.normalized_filename(subf)
 
1541
                    if subf_norm != subf and can_access:
 
1542
                        if subf_norm not in dir_entry.children:
 
1543
                            fl.append(subf_norm)
 
1544
                    else:
 
1545
                        fl.append(subf)
 
1546
            
 
1547
            fl.sort()
 
1548
            for subf in fl:
 
1549
                subp = pathjoin(path, subf)
 
1550
                yield subp
 
1551
 
 
1552
    def ignored_files(self):
 
1553
        """Yield list of PATH, IGNORE_PATTERN"""
 
1554
        for subp in self.extras():
 
1555
            pat = self.is_ignored(subp)
 
1556
            if pat is not None:
 
1557
                yield subp, pat
 
1558
 
 
1559
    def get_ignore_list(self):
 
1560
        """Return list of ignore patterns.
 
1561
 
 
1562
        Cached in the Tree object after the first call.
 
1563
        """
 
1564
        ignoreset = getattr(self, '_ignoreset', None)
 
1565
        if ignoreset is not None:
 
1566
            return ignoreset
 
1567
 
 
1568
        ignore_globs = set(bzrlib.DEFAULT_IGNORE)
 
1569
        ignore_globs.update(ignores.get_runtime_ignores())
 
1570
        ignore_globs.update(ignores.get_user_ignores())
 
1571
        if self.has_filename(bzrlib.IGNORE_FILENAME):
 
1572
            f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
 
1573
            try:
 
1574
                ignore_globs.update(ignores.parse_ignore_file(f))
 
1575
            finally:
 
1576
                f.close()
 
1577
        self._ignoreset = ignore_globs
 
1578
        return ignore_globs
 
1579
 
 
1580
    def _flush_ignore_list_cache(self):
 
1581
        """Resets the cached ignore list to force a cache rebuild."""
 
1582
        self._ignoreset = None
 
1583
        self._ignoreglobster = None
 
1584
 
 
1585
    def is_ignored(self, filename):
 
1586
        r"""Check whether the filename matches an ignore pattern.
 
1587
 
 
1588
        Patterns containing '/' or '\' need to match the whole path;
 
1589
        others match against only the last component.
 
1590
 
 
1591
        If the file is ignored, returns the pattern which caused it to
 
1592
        be ignored, otherwise None.  So this can simply be used as a
 
1593
        boolean if desired."""
 
1594
        if getattr(self, '_ignoreglobster', None) is None:
 
1595
            self._ignoreglobster = globbing.Globster(self.get_ignore_list())
 
1596
        return self._ignoreglobster.match(filename)
 
1597
 
 
1598
    def kind(self, file_id):
 
1599
        return file_kind(self.id2abspath(file_id))
 
1600
 
 
1601
    def _comparison_data(self, entry, path):
 
1602
        abspath = self.abspath(path)
 
1603
        try:
 
1604
            stat_value = os.lstat(abspath)
 
1605
        except OSError, e:
 
1606
            if getattr(e, 'errno', None) == errno.ENOENT:
 
1607
                stat_value = None
 
1608
                kind = None
 
1609
                executable = False
 
1610
            else:
 
1611
                raise
 
1612
        else:
 
1613
            mode = stat_value.st_mode
 
1614
            kind = osutils.file_kind_from_stat_mode(mode)
 
1615
            if not supports_executable():
 
1616
                executable = entry.executable
 
1617
            else:
 
1618
                executable = bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
1619
        return kind, executable, stat_value
 
1620
 
 
1621
    def _file_size(self, entry, stat_value):
 
1622
        return stat_value.st_size
 
1623
 
 
1624
    def last_revision(self):
 
1625
        """Return the last revision of the branch for this tree.
 
1626
 
 
1627
        This format tree does not support a separate marker for last-revision
 
1628
        compared to the branch.
 
1629
 
 
1630
        See MutableTree.last_revision
 
1631
        """
 
1632
        return self._last_revision()
 
1633
 
 
1634
    @needs_read_lock
 
1635
    def _last_revision(self):
 
1636
        """helper for get_parent_ids."""
 
1637
        return self.branch.last_revision()
 
1638
 
 
1639
    def is_locked(self):
 
1640
        return self._control_files.is_locked()
 
1641
 
 
1642
    def lock_read(self):
 
1643
        """See Branch.lock_read, and WorkingTree.unlock."""
 
1644
        self.branch.lock_read()
 
1645
        try:
 
1646
            return self._control_files.lock_read()
 
1647
        except:
 
1648
            self.branch.unlock()
 
1649
            raise
 
1650
 
 
1651
    def lock_tree_write(self):
 
1652
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
 
1653
        self.branch.lock_read()
 
1654
        try:
 
1655
            return self._control_files.lock_write()
 
1656
        except:
 
1657
            self.branch.unlock()
 
1658
            raise
 
1659
 
 
1660
    def lock_write(self):
 
1661
        """See MutableTree.lock_write, and WorkingTree.unlock."""
 
1662
        self.branch.lock_write()
 
1663
        try:
 
1664
            return self._control_files.lock_write()
 
1665
        except:
 
1666
            self.branch.unlock()
 
1667
            raise
 
1668
 
 
1669
    def get_physical_lock_status(self):
 
1670
        return self._control_files.get_physical_lock_status()
 
1671
 
 
1672
    def _basis_inventory_name(self):
 
1673
        return 'basis-inventory-cache'
 
1674
 
 
1675
    @needs_tree_write_lock
 
1676
    def set_last_revision(self, new_revision):
 
1677
        """Change the last revision in the working tree."""
 
1678
        new_revision = osutils.safe_revision_id(new_revision)
 
1679
        if self._change_last_revision(new_revision):
 
1680
            self._cache_basis_inventory(new_revision)
 
1681
 
 
1682
    def _change_last_revision(self, new_revision):
 
1683
        """Template method part of set_last_revision to perform the change.
 
1684
        
 
1685
        This is used to allow WorkingTree3 instances to not affect branch
 
1686
        when their last revision is set.
 
1687
        """
 
1688
        if new_revision is None:
 
1689
            self.branch.set_revision_history([])
 
1690
            return False
 
1691
        try:
 
1692
            self.branch.generate_revision_history(new_revision)
 
1693
        except errors.NoSuchRevision:
 
1694
            # not present in the repo - dont try to set it deeper than the tip
 
1695
            self.branch.set_revision_history([new_revision])
 
1696
        return True
 
1697
 
 
1698
    def _write_basis_inventory(self, xml):
 
1699
        """Write the basis inventory XML to the basis-inventory file"""
 
1700
        assert isinstance(xml, str), 'serialised xml must be bytestring.'
 
1701
        path = self._basis_inventory_name()
 
1702
        sio = StringIO(xml)
 
1703
        self._control_files.put(path, sio)
 
1704
 
 
1705
    def _create_basis_xml_from_inventory(self, revision_id, inventory):
 
1706
        """Create the text that will be saved in basis-inventory"""
 
1707
        # TODO: jam 20070209 This should be redundant, as the revision_id
 
1708
        #       as all callers should have already converted the revision_id to
 
1709
        #       utf8
 
1710
        inventory.revision_id = osutils.safe_revision_id(revision_id)
 
1711
        return xml7.serializer_v7.write_inventory_to_string(inventory)
 
1712
 
 
1713
    def _cache_basis_inventory(self, new_revision):
 
1714
        """Cache new_revision as the basis inventory."""
 
1715
        # TODO: this should allow the ready-to-use inventory to be passed in,
 
1716
        # as commit already has that ready-to-use [while the format is the
 
1717
        # same, that is].
 
1718
        try:
 
1719
            # this double handles the inventory - unpack and repack - 
 
1720
            # but is easier to understand. We can/should put a conditional
 
1721
            # in here based on whether the inventory is in the latest format
 
1722
            # - perhaps we should repack all inventories on a repository
 
1723
            # upgrade ?
 
1724
            # the fast path is to copy the raw xml from the repository. If the
 
1725
            # xml contains 'revision_id="', then we assume the right 
 
1726
            # revision_id is set. We must check for this full string, because a
 
1727
            # root node id can legitimately look like 'revision_id' but cannot
 
1728
            # contain a '"'.
 
1729
            xml = self.branch.repository.get_inventory_xml(new_revision)
 
1730
            firstline = xml.split('\n', 1)[0]
 
1731
            if (not 'revision_id="' in firstline or 
 
1732
                'format="7"' not in firstline):
 
1733
                inv = self.branch.repository.deserialise_inventory(
 
1734
                    new_revision, xml)
 
1735
                xml = self._create_basis_xml_from_inventory(new_revision, inv)
 
1736
            self._write_basis_inventory(xml)
 
1737
        except (errors.NoSuchRevision, errors.RevisionNotPresent):
 
1738
            pass
 
1739
 
 
1740
    def read_basis_inventory(self):
 
1741
        """Read the cached basis inventory."""
 
1742
        path = self._basis_inventory_name()
 
1743
        return self._control_files.get(path).read()
 
1744
        
 
1745
    @needs_read_lock
 
1746
    def read_working_inventory(self):
 
1747
        """Read the working inventory.
 
1748
        
 
1749
        :raises errors.InventoryModified: read_working_inventory will fail
 
1750
            when the current in memory inventory has been modified.
 
1751
        """
 
1752
        # conceptually this should be an implementation detail of the tree. 
 
1753
        # XXX: Deprecate this.
 
1754
        # ElementTree does its own conversion from UTF-8, so open in
 
1755
        # binary.
 
1756
        if self._inventory_is_modified:
 
1757
            raise errors.InventoryModified(self)
 
1758
        result = self._deserialize(self._control_files.get('inventory'))
 
1759
        self._set_inventory(result, dirty=False)
 
1760
        return result
 
1761
 
 
1762
    @needs_tree_write_lock
 
1763
    def remove(self, files, verbose=False, to_file=None):
 
1764
        """Remove nominated files from the working inventory..
 
1765
 
 
1766
        This does not remove their text.  This does not run on XXX on what? RBC
 
1767
 
 
1768
        TODO: Refuse to remove modified files unless --force is given?
 
1769
 
 
1770
        TODO: Do something useful with directories.
 
1771
 
 
1772
        TODO: Should this remove the text or not?  Tough call; not
 
1773
        removing may be useful and the user can just use use rm, and
 
1774
        is the opposite of add.  Removing it is consistent with most
 
1775
        other tools.  Maybe an option.
 
1776
        """
 
1777
        ## TODO: Normalize names
 
1778
        ## TODO: Remove nested loops; better scalability
 
1779
        if isinstance(files, basestring):
 
1780
            files = [files]
 
1781
 
 
1782
        inv = self.inventory
 
1783
 
 
1784
        # do this before any modifications
 
1785
        for f in files:
 
1786
            fid = inv.path2id(f)
 
1787
            if not fid:
 
1788
                note("%s is not versioned."%f)
 
1789
            else:
 
1790
                if verbose:
 
1791
                    # having remove it, it must be either ignored or unknown
 
1792
                    if self.is_ignored(f):
 
1793
                        new_status = 'I'
 
1794
                    else:
 
1795
                        new_status = '?'
 
1796
                    textui.show_status(new_status, inv[fid].kind, f,
 
1797
                                       to_file=to_file)
 
1798
                del inv[fid]
 
1799
 
 
1800
        self._write_inventory(inv)
 
1801
 
 
1802
    @needs_tree_write_lock
 
1803
    def revert(self, filenames, old_tree=None, backups=True, 
 
1804
               pb=DummyProgress(), report_changes=False):
 
1805
        from bzrlib.conflicts import resolve
 
1806
        if old_tree is None:
 
1807
            old_tree = self.basis_tree()
 
1808
        conflicts = transform.revert(self, old_tree, filenames, backups, pb,
 
1809
                                     report_changes)
 
1810
        if not len(filenames):
 
1811
            self.set_parent_ids(self.get_parent_ids()[:1])
 
1812
            resolve(self)
 
1813
        else:
 
1814
            resolve(self, filenames, ignore_misses=True)
 
1815
        return conflicts
 
1816
 
 
1817
    def revision_tree(self, revision_id):
 
1818
        """See Tree.revision_tree.
 
1819
 
 
1820
        WorkingTree can supply revision_trees for the basis revision only
 
1821
        because there is only one cached inventory in the bzr directory.
 
1822
        """
 
1823
        if revision_id == self.last_revision():
 
1824
            try:
 
1825
                xml = self.read_basis_inventory()
 
1826
            except errors.NoSuchFile:
 
1827
                pass
 
1828
            else:
 
1829
                try:
 
1830
                    inv = xml7.serializer_v7.read_inventory_from_string(xml)
 
1831
                    # dont use the repository revision_tree api because we want
 
1832
                    # to supply the inventory.
 
1833
                    if inv.revision_id == revision_id:
 
1834
                        return revisiontree.RevisionTree(self.branch.repository,
 
1835
                            inv, revision_id)
 
1836
                except errors.BadInventoryFormat:
 
1837
                    pass
 
1838
        # raise if there was no inventory, or if we read the wrong inventory.
 
1839
        raise errors.NoSuchRevisionInTree(self, revision_id)
 
1840
 
 
1841
    # XXX: This method should be deprecated in favour of taking in a proper
 
1842
    # new Inventory object.
 
1843
    @needs_tree_write_lock
 
1844
    def set_inventory(self, new_inventory_list):
 
1845
        from bzrlib.inventory import (Inventory,
 
1846
                                      InventoryDirectory,
 
1847
                                      InventoryEntry,
 
1848
                                      InventoryFile,
 
1849
                                      InventoryLink)
 
1850
        inv = Inventory(self.get_root_id())
 
1851
        for path, file_id, parent, kind in new_inventory_list:
 
1852
            name = os.path.basename(path)
 
1853
            if name == "":
 
1854
                continue
 
1855
            # fixme, there should be a factory function inv,add_?? 
 
1856
            if kind == 'directory':
 
1857
                inv.add(InventoryDirectory(file_id, name, parent))
 
1858
            elif kind == 'file':
 
1859
                inv.add(InventoryFile(file_id, name, parent))
 
1860
            elif kind == 'symlink':
 
1861
                inv.add(InventoryLink(file_id, name, parent))
 
1862
            else:
 
1863
                raise errors.BzrError("unknown kind %r" % kind)
 
1864
        self._write_inventory(inv)
 
1865
 
 
1866
    @needs_tree_write_lock
 
1867
    def set_root_id(self, file_id):
 
1868
        """Set the root id for this tree."""
 
1869
        # for compatability 
 
1870
        if file_id is None:
 
1871
            symbol_versioning.warn(symbol_versioning.zero_twelve
 
1872
                % 'WorkingTree.set_root_id with fileid=None',
 
1873
                DeprecationWarning,
 
1874
                stacklevel=3)
 
1875
            file_id = ROOT_ID
 
1876
        else:
 
1877
            file_id = osutils.safe_file_id(file_id)
 
1878
        self._set_root_id(file_id)
 
1879
 
 
1880
    def _set_root_id(self, file_id):
 
1881
        """Set the root id for this tree, in a format specific manner.
 
1882
 
 
1883
        :param file_id: The file id to assign to the root. It must not be 
 
1884
            present in the current inventory or an error will occur. It must
 
1885
            not be None, but rather a valid file id.
 
1886
        """
 
1887
        inv = self._inventory
 
1888
        orig_root_id = inv.root.file_id
 
1889
        # TODO: it might be nice to exit early if there was nothing
 
1890
        # to do, saving us from trigger a sync on unlock.
 
1891
        self._inventory_is_modified = True
 
1892
        # we preserve the root inventory entry object, but
 
1893
        # unlinkit from the byid index
 
1894
        del inv._byid[inv.root.file_id]
 
1895
        inv.root.file_id = file_id
 
1896
        # and link it into the index with the new changed id.
 
1897
        inv._byid[inv.root.file_id] = inv.root
 
1898
        # and finally update all children to reference the new id.
 
1899
        # XXX: this should be safe to just look at the root.children
 
1900
        # list, not the WHOLE INVENTORY.
 
1901
        for fid in inv:
 
1902
            entry = inv[fid]
 
1903
            if entry.parent_id == orig_root_id:
 
1904
                entry.parent_id = inv.root.file_id
 
1905
 
 
1906
    def unlock(self):
 
1907
        """See Branch.unlock.
 
1908
        
 
1909
        WorkingTree locking just uses the Branch locking facilities.
 
1910
        This is current because all working trees have an embedded branch
 
1911
        within them. IF in the future, we were to make branch data shareable
 
1912
        between multiple working trees, i.e. via shared storage, then we 
 
1913
        would probably want to lock both the local tree, and the branch.
 
1914
        """
 
1915
        raise NotImplementedError(self.unlock)
 
1916
 
 
1917
    def update(self):
 
1918
        """Update a working tree along its branch.
 
1919
 
 
1920
        This will update the branch if its bound too, which means we have
 
1921
        multiple trees involved:
 
1922
 
 
1923
        - The new basis tree of the master.
 
1924
        - The old basis tree of the branch.
 
1925
        - The old basis tree of the working tree.
 
1926
        - The current working tree state.
 
1927
 
 
1928
        Pathologically, all three may be different, and non-ancestors of each
 
1929
        other.  Conceptually we want to:
 
1930
 
 
1931
        - Preserve the wt.basis->wt.state changes
 
1932
        - Transform the wt.basis to the new master basis.
 
1933
        - Apply a merge of the old branch basis to get any 'local' changes from
 
1934
          it into the tree.
 
1935
        - Restore the wt.basis->wt.state changes.
 
1936
 
 
1937
        There isn't a single operation at the moment to do that, so we:
 
1938
        - Merge current state -> basis tree of the master w.r.t. the old tree
 
1939
          basis.
 
1940
        - Do a 'normal' merge of the old branch basis if it is relevant.
 
1941
        """
 
1942
        if self.branch.get_master_branch() is not None:
 
1943
            self.lock_write()
 
1944
            update_branch = True
 
1945
        else:
 
1946
            self.lock_tree_write()
 
1947
            update_branch = False
 
1948
        try:
 
1949
            if update_branch:
 
1950
                old_tip = self.branch.update()
 
1951
            else:
 
1952
                old_tip = None
 
1953
            return self._update_tree(old_tip)
 
1954
        finally:
 
1955
            self.unlock()
 
1956
 
 
1957
    @needs_tree_write_lock
 
1958
    def _update_tree(self, old_tip=None):
 
1959
        """Update a tree to the master branch.
 
1960
 
 
1961
        :param old_tip: if supplied, the previous tip revision the branch,
 
1962
            before it was changed to the master branch's tip.
 
1963
        """
 
1964
        # here if old_tip is not None, it is the old tip of the branch before
 
1965
        # it was updated from the master branch. This should become a pending
 
1966
        # merge in the working tree to preserve the user existing work.  we
 
1967
        # cant set that until we update the working trees last revision to be
 
1968
        # one from the new branch, because it will just get absorbed by the
 
1969
        # parent de-duplication logic.
 
1970
        # 
 
1971
        # We MUST save it even if an error occurs, because otherwise the users
 
1972
        # local work is unreferenced and will appear to have been lost.
 
1973
        # 
 
1974
        result = 0
 
1975
        try:
 
1976
            last_rev = self.get_parent_ids()[0]
 
1977
        except IndexError:
 
1978
            last_rev = None
 
1979
        if last_rev != self.branch.last_revision():
 
1980
            # merge tree state up to new branch tip.
 
1981
            basis = self.basis_tree()
 
1982
            basis.lock_read()
 
1983
            try:
 
1984
                to_tree = self.branch.basis_tree()
 
1985
                if basis.inventory.root is None:
 
1986
                    self.set_root_id(to_tree.inventory.root.file_id)
 
1987
                    self.flush()
 
1988
                result += merge.merge_inner(
 
1989
                                      self.branch,
 
1990
                                      to_tree,
 
1991
                                      basis,
 
1992
                                      this_tree=self)
 
1993
            finally:
 
1994
                basis.unlock()
 
1995
            # TODO - dedup parents list with things merged by pull ?
 
1996
            # reuse the tree we've updated to to set the basis:
 
1997
            parent_trees = [(self.branch.last_revision(), to_tree)]
 
1998
            merges = self.get_parent_ids()[1:]
 
1999
            # Ideally we ask the tree for the trees here, that way the working
 
2000
            # tree can decide whether to give us teh entire tree or give us a
 
2001
            # lazy initialised tree. dirstate for instance will have the trees
 
2002
            # in ram already, whereas a last-revision + basis-inventory tree
 
2003
            # will not, but also does not need them when setting parents.
 
2004
            for parent in merges:
 
2005
                parent_trees.append(
 
2006
                    (parent, self.branch.repository.revision_tree(parent)))
 
2007
            if old_tip is not None:
 
2008
                parent_trees.append(
 
2009
                    (old_tip, self.branch.repository.revision_tree(old_tip)))
 
2010
            self.set_parent_trees(parent_trees)
 
2011
            last_rev = parent_trees[0][0]
 
2012
        else:
 
2013
            # the working tree had the same last-revision as the master
 
2014
            # branch did. We may still have pivot local work from the local
 
2015
            # branch into old_tip:
 
2016
            if old_tip is not None:
 
2017
                self.add_parent_tree_id(old_tip)
 
2018
        if old_tip and old_tip != last_rev:
 
2019
            # our last revision was not the prior branch last revision
 
2020
            # and we have converted that last revision to a pending merge.
 
2021
            # base is somewhere between the branch tip now
 
2022
            # and the now pending merge
 
2023
 
 
2024
            # Since we just modified the working tree and inventory, flush out
 
2025
            # the current state, before we modify it again.
 
2026
            # TODO: jam 20070214 WorkingTree3 doesn't require this, dirstate
 
2027
            #       requires it only because TreeTransform directly munges the
 
2028
            #       inventory and calls tree._write_inventory(). Ultimately we
 
2029
            #       should be able to remove this extra flush.
 
2030
            self.flush()
 
2031
            from bzrlib.revision import common_ancestor
 
2032
            try:
 
2033
                base_rev_id = common_ancestor(self.branch.last_revision(),
 
2034
                                              old_tip,
 
2035
                                              self.branch.repository)
 
2036
            except errors.NoCommonAncestor:
 
2037
                base_rev_id = None
 
2038
            base_tree = self.branch.repository.revision_tree(base_rev_id)
 
2039
            other_tree = self.branch.repository.revision_tree(old_tip)
 
2040
            result += merge.merge_inner(
 
2041
                                  self.branch,
 
2042
                                  other_tree,
 
2043
                                  base_tree,
 
2044
                                  this_tree=self)
 
2045
        return result
 
2046
 
 
2047
    def _write_hashcache_if_dirty(self):
 
2048
        """Write out the hashcache if it is dirty."""
 
2049
        if self._hashcache.needs_write:
 
2050
            try:
 
2051
                self._hashcache.write()
 
2052
            except OSError, e:
 
2053
                if e.errno not in (errno.EPERM, errno.EACCES):
 
2054
                    raise
 
2055
                # TODO: jam 20061219 Should this be a warning? A single line
 
2056
                #       warning might be sufficient to let the user know what
 
2057
                #       is going on.
 
2058
                mutter('Could not write hashcache for %s\nError: %s',
 
2059
                       self._hashcache.cache_file_name(), e)
 
2060
 
 
2061
    @needs_tree_write_lock
 
2062
    def _write_inventory(self, inv):
 
2063
        """Write inventory as the current inventory."""
 
2064
        self._set_inventory(inv, dirty=True)
 
2065
        self.flush()
 
2066
 
 
2067
    def set_conflicts(self, arg):
 
2068
        raise errors.UnsupportedOperation(self.set_conflicts, self)
 
2069
 
 
2070
    def add_conflicts(self, arg):
 
2071
        raise errors.UnsupportedOperation(self.add_conflicts, self)
 
2072
 
 
2073
    @needs_read_lock
 
2074
    def conflicts(self):
 
2075
        conflicts = _mod_conflicts.ConflictList()
 
2076
        for conflicted in self._iter_conflicts():
 
2077
            text = True
 
2078
            try:
 
2079
                if file_kind(self.abspath(conflicted)) != "file":
 
2080
                    text = False
 
2081
            except errors.NoSuchFile:
 
2082
                text = False
 
2083
            if text is True:
 
2084
                for suffix in ('.THIS', '.OTHER'):
 
2085
                    try:
 
2086
                        kind = file_kind(self.abspath(conflicted+suffix))
 
2087
                        if kind != "file":
 
2088
                            text = False
 
2089
                    except errors.NoSuchFile:
 
2090
                        text = False
 
2091
                    if text == False:
 
2092
                        break
 
2093
            ctype = {True: 'text conflict', False: 'contents conflict'}[text]
 
2094
            conflicts.append(_mod_conflicts.Conflict.factory(ctype,
 
2095
                             path=conflicted,
 
2096
                             file_id=self.path2id(conflicted)))
 
2097
        return conflicts
 
2098
 
 
2099
    def walkdirs(self, prefix=""):
 
2100
        """Walk the directories of this tree.
 
2101
 
 
2102
        This API returns a generator, which is only valid during the current
 
2103
        tree transaction - within a single lock_read or lock_write duration.
 
2104
 
 
2105
        If the tree is not locked, it may cause an error to be raised, depending
 
2106
        on the tree implementation.
 
2107
        """
 
2108
        disk_top = self.abspath(prefix)
 
2109
        if disk_top.endswith('/'):
 
2110
            disk_top = disk_top[:-1]
 
2111
        top_strip_len = len(disk_top) + 1
 
2112
        inventory_iterator = self._walkdirs(prefix)
 
2113
        disk_iterator = osutils.walkdirs(disk_top, prefix)
 
2114
        try:
 
2115
            current_disk = disk_iterator.next()
 
2116
            disk_finished = False
 
2117
        except OSError, e:
 
2118
            if e.errno != errno.ENOENT:
 
2119
                raise
 
2120
            current_disk = None
 
2121
            disk_finished = True
 
2122
        try:
 
2123
            current_inv = inventory_iterator.next()
 
2124
            inv_finished = False
 
2125
        except StopIteration:
 
2126
            current_inv = None
 
2127
            inv_finished = True
 
2128
        while not inv_finished or not disk_finished:
 
2129
            if not disk_finished:
 
2130
                # strip out .bzr dirs
 
2131
                if current_disk[0][1][top_strip_len:] == '':
 
2132
                    # osutils.walkdirs can be made nicer - 
 
2133
                    # yield the path-from-prefix rather than the pathjoined
 
2134
                    # value.
 
2135
                    bzrdir_loc = bisect_left(current_disk[1], ('.bzr', '.bzr'))
 
2136
                    if current_disk[1][bzrdir_loc][0] == '.bzr':
 
2137
                        # we dont yield the contents of, or, .bzr itself.
 
2138
                        del current_disk[1][bzrdir_loc]
 
2139
            if inv_finished:
 
2140
                # everything is unknown
 
2141
                direction = 1
 
2142
            elif disk_finished:
 
2143
                # everything is missing
 
2144
                direction = -1
 
2145
            else:
 
2146
                direction = cmp(current_inv[0][0], current_disk[0][0])
 
2147
            if direction > 0:
 
2148
                # disk is before inventory - unknown
 
2149
                dirblock = [(relpath, basename, kind, stat, None, None) for
 
2150
                    relpath, basename, kind, stat, top_path in current_disk[1]]
 
2151
                yield (current_disk[0][0], None), dirblock
 
2152
                try:
 
2153
                    current_disk = disk_iterator.next()
 
2154
                except StopIteration:
 
2155
                    disk_finished = True
 
2156
            elif direction < 0:
 
2157
                # inventory is before disk - missing.
 
2158
                dirblock = [(relpath, basename, 'unknown', None, fileid, kind)
 
2159
                    for relpath, basename, dkind, stat, fileid, kind in 
 
2160
                    current_inv[1]]
 
2161
                yield (current_inv[0][0], current_inv[0][1]), dirblock
 
2162
                try:
 
2163
                    current_inv = inventory_iterator.next()
 
2164
                except StopIteration:
 
2165
                    inv_finished = True
 
2166
            else:
 
2167
                # versioned present directory
 
2168
                # merge the inventory and disk data together
 
2169
                dirblock = []
 
2170
                for relpath, subiterator in itertools.groupby(sorted(
 
2171
                    current_inv[1] + current_disk[1], key=operator.itemgetter(0)), operator.itemgetter(1)):
 
2172
                    path_elements = list(subiterator)
 
2173
                    if len(path_elements) == 2:
 
2174
                        inv_row, disk_row = path_elements
 
2175
                        # versioned, present file
 
2176
                        dirblock.append((inv_row[0],
 
2177
                            inv_row[1], disk_row[2],
 
2178
                            disk_row[3], inv_row[4],
 
2179
                            inv_row[5]))
 
2180
                    elif len(path_elements[0]) == 5:
 
2181
                        # unknown disk file
 
2182
                        dirblock.append((path_elements[0][0],
 
2183
                            path_elements[0][1], path_elements[0][2],
 
2184
                            path_elements[0][3], None, None))
 
2185
                    elif len(path_elements[0]) == 6:
 
2186
                        # versioned, absent file.
 
2187
                        dirblock.append((path_elements[0][0],
 
2188
                            path_elements[0][1], 'unknown', None,
 
2189
                            path_elements[0][4], path_elements[0][5]))
 
2190
                    else:
 
2191
                        raise NotImplementedError('unreachable code')
 
2192
                yield current_inv[0], dirblock
 
2193
                try:
 
2194
                    current_inv = inventory_iterator.next()
 
2195
                except StopIteration:
 
2196
                    inv_finished = True
 
2197
                try:
 
2198
                    current_disk = disk_iterator.next()
 
2199
                except StopIteration:
 
2200
                    disk_finished = True
 
2201
 
 
2202
    def _walkdirs(self, prefix=""):
 
2203
        _directory = 'directory'
 
2204
        # get the root in the inventory
 
2205
        inv = self.inventory
 
2206
        top_id = inv.path2id(prefix)
 
2207
        if top_id is None:
 
2208
            pending = []
 
2209
        else:
 
2210
            pending = [(prefix, '', _directory, None, top_id, None)]
 
2211
        while pending:
 
2212
            dirblock = []
 
2213
            currentdir = pending.pop()
 
2214
            # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
 
2215
            top_id = currentdir[4]
 
2216
            if currentdir[0]:
 
2217
                relroot = currentdir[0] + '/'
 
2218
            else:
 
2219
                relroot = ""
 
2220
            # FIXME: stash the node in pending
 
2221
            entry = inv[top_id]
 
2222
            for name, child in entry.sorted_children():
 
2223
                dirblock.append((relroot + name, name, child.kind, None,
 
2224
                    child.file_id, child.kind
 
2225
                    ))
 
2226
            yield (currentdir[0], entry.file_id), dirblock
 
2227
            # push the user specified dirs from dirblock
 
2228
            for dir in reversed(dirblock):
 
2229
                if dir[2] == _directory:
 
2230
                    pending.append(dir)
 
2231
 
 
2232
 
 
2233
class WorkingTree2(WorkingTree):
 
2234
    """This is the Format 2 working tree.
 
2235
 
 
2236
    This was the first weave based working tree. 
 
2237
     - uses os locks for locking.
 
2238
     - uses the branch last-revision.
 
2239
    """
 
2240
 
 
2241
    def lock_tree_write(self):
 
2242
        """See WorkingTree.lock_tree_write().
 
2243
 
 
2244
        In Format2 WorkingTrees we have a single lock for the branch and tree
 
2245
        so lock_tree_write() degrades to lock_write().
 
2246
        """
 
2247
        self.branch.lock_write()
 
2248
        try:
 
2249
            return self._control_files.lock_write()
 
2250
        except:
 
2251
            self.branch.unlock()
 
2252
            raise
 
2253
 
 
2254
    def unlock(self):
 
2255
        # we share control files:
 
2256
        if self._control_files._lock_count == 3:
 
2257
            # _inventory_is_modified is always False during a read lock.
 
2258
            if self._inventory_is_modified:
 
2259
                self.flush()
 
2260
            self._write_hashcache_if_dirty()
 
2261
                    
 
2262
        # reverse order of locking.
 
2263
        try:
 
2264
            return self._control_files.unlock()
 
2265
        finally:
 
2266
            self.branch.unlock()
 
2267
 
 
2268
 
 
2269
class WorkingTree3(WorkingTree):
 
2270
    """This is the Format 3 working tree.
 
2271
 
 
2272
    This differs from the base WorkingTree by:
 
2273
     - having its own file lock
 
2274
     - having its own last-revision property.
 
2275
 
 
2276
    This is new in bzr 0.8
 
2277
    """
 
2278
 
 
2279
    @needs_read_lock
 
2280
    def _last_revision(self):
 
2281
        """See Mutable.last_revision."""
 
2282
        try:
 
2283
            return osutils.safe_revision_id(
 
2284
                        self._control_files.get('last-revision').read())
 
2285
        except errors.NoSuchFile:
 
2286
            return None
 
2287
 
 
2288
    def _change_last_revision(self, revision_id):
 
2289
        """See WorkingTree._change_last_revision."""
 
2290
        if revision_id is None or revision_id == NULL_REVISION:
 
2291
            try:
 
2292
                self._control_files._transport.delete('last-revision')
 
2293
            except errors.NoSuchFile:
 
2294
                pass
 
2295
            return False
 
2296
        else:
 
2297
            self._control_files.put_bytes('last-revision', revision_id)
 
2298
            return True
 
2299
 
 
2300
    @needs_tree_write_lock
 
2301
    def set_conflicts(self, conflicts):
 
2302
        self._put_rio('conflicts', conflicts.to_stanzas(), 
 
2303
                      CONFLICT_HEADER_1)
 
2304
 
 
2305
    @needs_tree_write_lock
 
2306
    def add_conflicts(self, new_conflicts):
 
2307
        conflict_set = set(self.conflicts())
 
2308
        conflict_set.update(set(list(new_conflicts)))
 
2309
        self.set_conflicts(_mod_conflicts.ConflictList(sorted(conflict_set,
 
2310
                                       key=_mod_conflicts.Conflict.sort_key)))
 
2311
 
 
2312
    @needs_read_lock
 
2313
    def conflicts(self):
 
2314
        try:
 
2315
            confile = self._control_files.get('conflicts')
 
2316
        except errors.NoSuchFile:
 
2317
            return _mod_conflicts.ConflictList()
 
2318
        try:
 
2319
            if confile.next() != CONFLICT_HEADER_1 + '\n':
 
2320
                raise errors.ConflictFormatError()
 
2321
        except StopIteration:
 
2322
            raise errors.ConflictFormatError()
 
2323
        return _mod_conflicts.ConflictList.from_stanzas(RioReader(confile))
 
2324
 
 
2325
    def unlock(self):
 
2326
        if self._control_files._lock_count == 1:
 
2327
            # _inventory_is_modified is always False during a read lock.
 
2328
            if self._inventory_is_modified:
 
2329
                self.flush()
 
2330
            self._write_hashcache_if_dirty()
 
2331
        # reverse order of locking.
 
2332
        try:
 
2333
            return self._control_files.unlock()
 
2334
        finally:
 
2335
            self.branch.unlock()
 
2336
 
 
2337
 
 
2338
class WorkingTreeAB1(WorkingTree3):
 
2339
 
 
2340
    def _serialize(self, inventory, out_file):
 
2341
        xml7.serializer_v7.write_inventory(self._inventory, out_file)
 
2342
 
 
2343
    def _deserialize(selt, in_file):
 
2344
        return xml7.serializer_v7.read_inventory(in_file)
 
2345
 
 
2346
    def _comparison_data(self, entry, path):
 
2347
        kind, executable, stat_value = \
 
2348
            WorkingTree3._comparison_data(self, entry, path)
 
2349
        if kind == 'directory' and entry.kind == 'tree-reference':
 
2350
            kind = 'tree-reference'
 
2351
        return kind, executable, stat_value
 
2352
 
 
2353
    def kind(self, file_id):
 
2354
        kind = WorkingTree3.kind(self, file_id)
 
2355
        if kind == 'directory':
 
2356
            entry = self.inventory[file_id]
 
2357
            if entry.kind == 'tree-reference':
 
2358
                kind = 'tree-reference'
 
2359
        return kind
 
2360
 
 
2361
    def add_reference(self, sub_tree):
 
2362
        try:
 
2363
            sub_tree_path = self.relpath(sub_tree.basedir)
 
2364
        except errors.PathNotChild:
 
2365
            raise errors.BadReferenceTarget(self, sub_tree, 
 
2366
                                            'Target not inside tree.')
 
2367
        parent_id = self.path2id(osutils.dirname(sub_tree_path))
 
2368
        name = osutils.basename(sub_tree_path)
 
2369
        sub_tree_id = sub_tree.get_root_id()
 
2370
        if sub_tree_id == self.get_root_id():
 
2371
            raise errors.BadReferenceTarget(self, sub_tree, 
 
2372
                                     'Trees have the same root id.')
 
2373
        if sub_tree_id in self.inventory:
 
2374
            raise errors.BadReferenceTarget(self, sub_tree, 
 
2375
                                            'Root id already present in tree')
 
2376
        entry = TreeReference(sub_tree_id, name, parent_id, None, 
 
2377
                              None)
 
2378
        self.inventory.add(entry)
 
2379
        self._write_inventory(self.inventory)
 
2380
 
 
2381
    def get_nested_tree(self, entry, path=None):
 
2382
        if path is None:
 
2383
            path = self.id2path(entry.file_id)
 
2384
        return WorkingTree.open(self.abspath(path))
 
2385
 
 
2386
    def get_reference_revision(self, entry, path=None):
 
2387
        return self.get_nested_tree(entry, path).last_revision()
 
2388
 
 
2389
 
 
2390
def get_conflicted_stem(path):
 
2391
    for suffix in _mod_conflicts.CONFLICT_SUFFIXES:
 
2392
        if path.endswith(suffix):
 
2393
            return path[:-len(suffix)]
 
2394
 
 
2395
 
 
2396
@deprecated_function(zero_eight)
 
2397
def is_control_file(filename):
 
2398
    """See WorkingTree.is_control_filename(filename)."""
 
2399
    ## FIXME: better check
 
2400
    filename = normpath(filename)
 
2401
    while filename != '':
 
2402
        head, tail = os.path.split(filename)
 
2403
        ## mutter('check %r for control file' % ((head, tail),))
 
2404
        if tail == '.bzr':
 
2405
            return True
 
2406
        if filename == head:
 
2407
            break
 
2408
        filename = head
 
2409
    return False
 
2410
 
 
2411
 
 
2412
class WorkingTreeFormat(object):
 
2413
    """An encapsulation of the initialization and open routines for a format.
 
2414
 
 
2415
    Formats provide three things:
 
2416
     * An initialization routine,
 
2417
     * a format string,
 
2418
     * an open routine.
 
2419
 
 
2420
    Formats are placed in an dict by their format string for reference 
 
2421
    during workingtree opening. Its not required that these be instances, they
 
2422
    can be classes themselves with class methods - it simply depends on 
 
2423
    whether state is needed for a given format or not.
 
2424
 
 
2425
    Once a format is deprecated, just deprecate the initialize and open
 
2426
    methods on the format class. Do not deprecate the object, as the 
 
2427
    object will be created every time regardless.
 
2428
    """
 
2429
 
 
2430
    _default_format = None
 
2431
    """The default format used for new trees."""
 
2432
 
 
2433
    _formats = {}
 
2434
    """The known formats."""
 
2435
 
 
2436
    requires_rich_root = False
 
2437
 
 
2438
    @classmethod
 
2439
    def find_format(klass, a_bzrdir):
 
2440
        """Return the format for the working tree object in a_bzrdir."""
 
2441
        try:
 
2442
            transport = a_bzrdir.get_workingtree_transport(None)
 
2443
            format_string = transport.get("format").read()
 
2444
            return klass._formats[format_string]
 
2445
        except errors.NoSuchFile:
 
2446
            raise errors.NoWorkingTree(base=transport.base)
 
2447
        except KeyError:
 
2448
            raise errors.UnknownFormatError(format=format_string)
 
2449
 
 
2450
    def __eq__(self, other):
 
2451
        return self.__class__ is other.__class__
 
2452
 
 
2453
    def __ne__(self, other):
 
2454
        return not (self == other)
 
2455
 
 
2456
    @classmethod
 
2457
    def get_default_format(klass):
 
2458
        """Return the current default format."""
 
2459
        return klass._default_format
 
2460
 
 
2461
    def get_format_string(self):
 
2462
        """Return the ASCII format string that identifies this format."""
 
2463
        raise NotImplementedError(self.get_format_string)
 
2464
 
 
2465
    def get_format_description(self):
 
2466
        """Return the short description for this format."""
 
2467
        raise NotImplementedError(self.get_format_description)
 
2468
 
 
2469
    def is_supported(self):
 
2470
        """Is this format supported?
 
2471
 
 
2472
        Supported formats can be initialized and opened.
 
2473
        Unsupported formats may not support initialization or committing or 
 
2474
        some other features depending on the reason for not being supported.
 
2475
        """
 
2476
        return True
 
2477
 
 
2478
    @classmethod
 
2479
    def register_format(klass, format):
 
2480
        klass._formats[format.get_format_string()] = format
 
2481
 
 
2482
    @classmethod
 
2483
    def set_default_format(klass, format):
 
2484
        klass._default_format = format
 
2485
 
 
2486
    @classmethod
 
2487
    def unregister_format(klass, format):
 
2488
        assert klass._formats[format.get_format_string()] is format
 
2489
        del klass._formats[format.get_format_string()]
 
2490
 
 
2491
 
 
2492
 
 
2493
class WorkingTreeFormat2(WorkingTreeFormat):
 
2494
    """The second working tree format. 
 
2495
 
 
2496
    This format modified the hash cache from the format 1 hash cache.
 
2497
    """
 
2498
 
 
2499
    def get_format_description(self):
 
2500
        """See WorkingTreeFormat.get_format_description()."""
 
2501
        return "Working tree format 2"
 
2502
 
 
2503
    def stub_initialize_remote(self, control_files):
 
2504
        """As a special workaround create critical control files for a remote working tree
 
2505
        
 
2506
        This ensures that it can later be updated and dealt with locally,
 
2507
        since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with 
 
2508
        no working tree.  (See bug #43064).
 
2509
        """
 
2510
        sio = StringIO()
 
2511
        inv = Inventory()
 
2512
        xml5.serializer_v5.write_inventory(inv, sio)
 
2513
        sio.seek(0)
 
2514
        control_files.put('inventory', sio)
 
2515
 
 
2516
        control_files.put_bytes('pending-merges', '')
 
2517
        
 
2518
 
 
2519
    def initialize(self, a_bzrdir, revision_id=None):
 
2520
        """See WorkingTreeFormat.initialize()."""
 
2521
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
2522
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
2523
        branch = a_bzrdir.open_branch()
 
2524
        if revision_id is not None:
 
2525
            revision_id = osutils.safe_revision_id(revision_id)
 
2526
            branch.lock_write()
 
2527
            try:
 
2528
                revision_history = branch.revision_history()
 
2529
                try:
 
2530
                    position = revision_history.index(revision_id)
 
2531
                except ValueError:
 
2532
                    raise errors.NoSuchRevision(branch, revision_id)
 
2533
                branch.set_revision_history(revision_history[:position + 1])
 
2534
            finally:
 
2535
                branch.unlock()
 
2536
        revision = branch.last_revision()
 
2537
        inv = Inventory()
 
2538
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
 
2539
                         branch,
 
2540
                         inv,
 
2541
                         _internal=True,
 
2542
                         _format=self,
 
2543
                         _bzrdir=a_bzrdir)
 
2544
        basis_tree = branch.repository.revision_tree(revision)
 
2545
        if basis_tree.inventory.root is not None:
 
2546
            wt.set_root_id(basis_tree.inventory.root.file_id)
 
2547
        # set the parent list and cache the basis tree.
 
2548
        wt.set_parent_trees([(revision, basis_tree)])
 
2549
        transform.build_tree(basis_tree, wt)
 
2550
        return wt
 
2551
 
 
2552
    def __init__(self):
 
2553
        super(WorkingTreeFormat2, self).__init__()
 
2554
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
 
2555
 
 
2556
    def open(self, a_bzrdir, _found=False):
 
2557
        """Return the WorkingTree object for a_bzrdir
 
2558
 
 
2559
        _found is a private parameter, do not use it. It is used to indicate
 
2560
               if format probing has already been done.
 
2561
        """
 
2562
        if not _found:
 
2563
            # we are being called directly and must probe.
 
2564
            raise NotImplementedError
 
2565
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
2566
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
2567
        return WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
 
2568
                           _internal=True,
 
2569
                           _format=self,
 
2570
                           _bzrdir=a_bzrdir)
 
2571
 
 
2572
 
 
2573
class WorkingTreeFormat3(WorkingTreeFormat):
 
2574
    """The second working tree format updated to record a format marker.
 
2575
 
 
2576
    This format:
 
2577
        - exists within a metadir controlling .bzr
 
2578
        - includes an explicit version marker for the workingtree control
 
2579
          files, separate from the BzrDir format
 
2580
        - modifies the hash cache format
 
2581
        - is new in bzr 0.8
 
2582
        - uses a LockDir to guard access for writes.
 
2583
    """
 
2584
 
 
2585
    def get_format_string(self):
 
2586
        """See WorkingTreeFormat.get_format_string()."""
 
2587
        return "Bazaar-NG Working Tree format 3"
 
2588
 
 
2589
    def get_format_description(self):
 
2590
        """See WorkingTreeFormat.get_format_description()."""
 
2591
        return "Working tree format 3"
 
2592
 
 
2593
    _lock_file_name = 'lock'
 
2594
    _lock_class = LockDir
 
2595
    _tree_class = WorkingTree3
 
2596
 
 
2597
    def __get_matchingbzrdir(self):
 
2598
        return bzrdir.BzrDirMetaFormat1()
 
2599
 
 
2600
    _matchingbzrdir = property(__get_matchingbzrdir)
 
2601
 
 
2602
    def _open_control_files(self, a_bzrdir):
 
2603
        transport = a_bzrdir.get_workingtree_transport(None)
 
2604
        return LockableFiles(transport, self._lock_file_name, 
 
2605
                             self._lock_class)
 
2606
 
 
2607
    def initialize(self, a_bzrdir, revision_id=None):
 
2608
        """See WorkingTreeFormat.initialize().
 
2609
        
 
2610
        revision_id allows creating a working tree at a different
 
2611
        revision than the branch is at.
 
2612
        """
 
2613
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
2614
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
2615
        transport = a_bzrdir.get_workingtree_transport(self)
 
2616
        control_files = self._open_control_files(a_bzrdir)
 
2617
        control_files.create_lock()
 
2618
        control_files.lock_write()
 
2619
        control_files.put_utf8('format', self.get_format_string())
 
2620
        branch = a_bzrdir.open_branch()
 
2621
        if revision_id is None:
 
2622
            revision_id = branch.last_revision()
 
2623
        else:
 
2624
            revision_id = osutils.safe_revision_id(revision_id)
 
2625
        # WorkingTree3 can handle an inventory which has a unique root id.
 
2626
        # as of bzr 0.12. However, bzr 0.11 and earlier fail to handle
 
2627
        # those trees. And because there isn't a format bump inbetween, we
 
2628
        # are maintaining compatibility with older clients.
 
2629
        # inv = Inventory(root_id=gen_root_id())
 
2630
        inv = self._initial_inventory()
 
2631
        wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
2632
                         branch,
 
2633
                         inv,
 
2634
                         _internal=True,
 
2635
                         _format=self,
 
2636
                         _bzrdir=a_bzrdir,
 
2637
                         _control_files=control_files)
 
2638
        wt.lock_tree_write()
 
2639
        try:
 
2640
            basis_tree = branch.repository.revision_tree(revision_id)
 
2641
            # only set an explicit root id if there is one to set.
 
2642
            if basis_tree.inventory.root is not None:
 
2643
                wt.set_root_id(basis_tree.inventory.root.file_id)
 
2644
            if revision_id == NULL_REVISION:
 
2645
                wt.set_parent_trees([])
 
2646
            else:
 
2647
                wt.set_parent_trees([(revision_id, basis_tree)])
 
2648
            transform.build_tree(basis_tree, wt)
 
2649
        finally:
 
2650
            # Unlock in this order so that the unlock-triggers-flush in
 
2651
            # WorkingTree is given a chance to fire.
 
2652
            control_files.unlock()
 
2653
            wt.unlock()
 
2654
        return wt
 
2655
 
 
2656
    def _initial_inventory(self):
 
2657
        return Inventory()
 
2658
 
 
2659
    def __init__(self):
 
2660
        super(WorkingTreeFormat3, self).__init__()
 
2661
 
 
2662
    def open(self, a_bzrdir, _found=False):
 
2663
        """Return the WorkingTree object for a_bzrdir
 
2664
 
 
2665
        _found is a private parameter, do not use it. It is used to indicate
 
2666
               if format probing has already been done.
 
2667
        """
 
2668
        if not _found:
 
2669
            # we are being called directly and must probe.
 
2670
            raise NotImplementedError
 
2671
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
2672
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
2673
        return self._open(a_bzrdir, self._open_control_files(a_bzrdir))
 
2674
 
 
2675
    def _open(self, a_bzrdir, control_files):
 
2676
        """Open the tree itself.
 
2677
        
 
2678
        :param a_bzrdir: the dir for the tree.
 
2679
        :param control_files: the control files for the tree.
 
2680
        """
 
2681
        return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
2682
                                _internal=True,
 
2683
                                _format=self,
 
2684
                                _bzrdir=a_bzrdir,
 
2685
                                _control_files=control_files)
 
2686
 
 
2687
    def __str__(self):
 
2688
        return self.get_format_string()
 
2689
 
 
2690
 
 
2691
class WorkingTreeFormatAB1(WorkingTreeFormat3):
 
2692
    
 
2693
    """Working tree format that supports unique roots and nested trees"""
 
2694
 
 
2695
    _tree_class = WorkingTreeAB1
 
2696
 
 
2697
    requires_rich_root = True
 
2698
 
 
2699
    supports_tree_reference = True
 
2700
 
 
2701
    def __init__(self):
 
2702
        WorkingTreeFormat3.__init__(self)
 
2703
        
 
2704
    def __get_matchingbzrdir(self):
 
2705
        return bzrdir.format_registry.make_bzrdir('experimental-knit3')
 
2706
 
 
2707
    _matchingbzrdir = property(__get_matchingbzrdir)
 
2708
 
 
2709
    def get_format_string(self):
 
2710
        """See WorkingTreeFormat.get_format_string()."""
 
2711
        return "Bazaar-NG Working Tree format AB1"
 
2712
 
 
2713
    def get_format_description(self):
 
2714
        """See WorkingTreeFormat.get_format_description()."""
 
2715
        return "Working tree format 4"
 
2716
 
 
2717
    def _initial_inventory(self):
 
2718
        return Inventory(root_id=generate_ids.gen_root_id())
 
2719
 
 
2720
# formats which have no format string are not discoverable
 
2721
# and not independently creatable, so are not registered.
 
2722
__default_format = WorkingTreeFormat3()
 
2723
WorkingTreeFormat.register_format(__default_format)
 
2724
WorkingTreeFormat.register_format(WorkingTreeFormat4())
 
2725
WorkingTreeFormat.register_format(WorkingTreeFormatAB1())
 
2726
WorkingTreeFormat.set_default_format(__default_format)
 
2727
# formats which have no format string are not discoverable
 
2728
# and not independently creatable, so are not registered.
 
2729
_legacy_formats = [WorkingTreeFormat2(),
 
2730
                   ]
 
2731
 
 
2732
 
 
2733
class WorkingTreeTestProviderAdapter(object):
 
2734
    """A tool to generate a suite testing multiple workingtree formats at once.
 
2735
 
 
2736
    This is done by copying the test once for each transport and injecting
 
2737
    the transport_server, transport_readonly_server, and workingtree_format
 
2738
    classes into each copy. Each copy is also given a new id() to make it
 
2739
    easy to identify.
 
2740
    """
 
2741
 
 
2742
    def __init__(self, transport_server, transport_readonly_server, formats):
 
2743
        self._transport_server = transport_server
 
2744
        self._transport_readonly_server = transport_readonly_server
 
2745
        self._formats = formats
 
2746
    
 
2747
    def _clone_test(self, test, bzrdir_format, workingtree_format, variation):
 
2748
        """Clone test for adaption."""
 
2749
        new_test = deepcopy(test)
 
2750
        new_test.transport_server = self._transport_server
 
2751
        new_test.transport_readonly_server = self._transport_readonly_server
 
2752
        new_test.bzrdir_format = bzrdir_format
 
2753
        new_test.workingtree_format = workingtree_format
 
2754
        def make_new_test_id():
 
2755
            new_id = "%s(%s)" % (test.id(), variation)
 
2756
            return lambda: new_id
 
2757
        new_test.id = make_new_test_id()
 
2758
        return new_test
 
2759
    
 
2760
    def adapt(self, test):
 
2761
        from bzrlib.tests import TestSuite
 
2762
        result = TestSuite()
 
2763
        for workingtree_format, bzrdir_format in self._formats:
 
2764
            new_test = self._clone_test(
 
2765
                test,
 
2766
                bzrdir_format,
 
2767
                workingtree_format, workingtree_format.__class__.__name__)
 
2768
            result.addTest(new_test)
 
2769
        return result