~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Martin
  • Date: 2010-05-03 20:55:05 UTC
  • mto: This revision was merged to the branch mainline in revision 5204.
  • Revision ID: gzlist@googlemail.com-20100503205505-okdad5rbf12osway
Include OverflowError in error types bencode translates, as Python 2.4 raises that rather than IndexError in some situations

Show diffs side-by-side

added added

removed removed

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