~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Aaron Bentley
  • Date: 2008-04-06 04:44:17 UTC
  • mto: This revision was merged to the branch mainline in revision 3364.
  • Revision ID: aaron@aaronbentley.com-20080406044417-v6lch0yugh7d1vtk
Implement conversion to standalone

Show diffs side-by-side

added added

removed removed

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