/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

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