← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

Merge bzr.dev and tree-file-ids-as-tuples.

Show diffs side-by-side

added added

removed removed

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