/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

  • Committer: Mark Hammond
  • Date: 2008-08-12 13:07:00 UTC
  • mto: (3691.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 3692.
  • Revision ID: mhammond@skippinet.com.au-20080812130700-05ohg06353nxg22q
eagerly unlock the result_basis to prevent handles staying open.

Show diffs side-by-side

added added

removed removed

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