~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Martin Pool
  • Date: 2005-05-05 02:29:38 UTC
  • Revision ID: mbp@sourcefrog.net-20050505022938-7e0f3e231299d920
- It's not an error to use the library without
  opening the trace file

Show diffs side-by-side

added added

removed removed

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