~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Ian Clatworthy
  • Date: 2009-01-19 02:24:15 UTC
  • mto: This revision was merged to the branch mainline in revision 3944.
  • Revision ID: ian.clatworthy@canonical.com-20090119022415-mo0mcfeiexfktgwt
apply jam's log --short fix (Ian Clatworthy)

Show diffs side-by-side

added added

removed removed

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