~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-05-19 06:14:38 UTC
  • mfrom: (1704.2.23 bzr.mbp.integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060519061438-6300caf3926c3cff
(mbp) small fixes

Show diffs side-by-side

added added

removed removed

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