~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Aaron Bentley
  • Date: 2007-12-12 15:17:13 UTC
  • mto: This revision was merged to the branch mainline in revision 3113.
  • Revision ID: abentley@panoramicfeedback.com-20071212151713-ox5n8rlx8m3nsspy
Add support for reconfiguring repositories into branches or trees

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