~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

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