/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 by-reference-trees

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