← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Martin Pool
  • Date: 2010-01-29 10:36:23 UTC
  • mto: This revision was merged to the branch mainline in revision 4992.
  • Revision ID: mbp@sourcefrog.net-20100129103623-hywka5hymo5z13jw
Change url to canonical.com or wiki, plus some doc improvements in passing

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""WorkingTree object and friends.
18
18
 
19
19
A WorkingTree represents the editable working copy of a branch.
20
 
Operations which represent the WorkingTree are also done here, 
21
 
such as renaming or adding files.  The WorkingTree has an inventory 
22
 
which is updated by these operations.  A commit produces a 
 
20
Operations which represent the WorkingTree are also done here,
 
21
such as renaming or adding files.  The WorkingTree has an inventory
 
22
which is updated by these operations.  A commit produces a
23
23
new revision based on the workingtree and its inventory.
24
24
 
25
25
At the moment every WorkingTree has its own branch.  Remote
38
38
 
39
39
from cStringIO import StringIO
40
40
import os
 
41
import sys
41
42
 
42
43
from bzrlib.lazy_import import lazy_import
43
44
lazy_import(globals(), """
44
45
from bisect import bisect_left
45
46
import collections
46
 
from copy import deepcopy
47
47
import errno
48
48
import itertools
49
49
import operator
50
50
import stat
51
 
from time import time
52
 
import warnings
53
51
import re
54
52
 
55
53
import bzrlib
57
55
    branch,
58
56
    bzrdir,
59
57
    conflicts as _mod_conflicts,
60
 
    dirstate,
61
58
    errors,
62
59
    generate_ids,
63
60
    globbing,
 
61
    graph as _mod_graph,
64
62
    hashcache,
65
63
    ignores,
 
64
    inventory,
66
65
    merge,
67
 
    osutils,
 
66
    revision as _mod_revision,
68
67
    revisiontree,
69
 
    repository,
70
 
    textui,
71
68
    trace,
72
69
    transform,
73
70
    ui,
74
 
    urlutils,
 
71
    views,
75
72
    xml5,
76
 
    xml6,
77
73
    xml7,
78
74
    )
79
75
import bzrlib.branch
80
76
from bzrlib.transport import get_transport
81
 
import bzrlib.ui
82
 
from bzrlib.workingtree_4 import WorkingTreeFormat4
 
77
from bzrlib.workingtree_4 import (
 
78
    WorkingTreeFormat4,
 
79
    WorkingTreeFormat5,
 
80
    WorkingTreeFormat6,
 
81
    )
83
82
""")
84
83
 
85
84
from bzrlib import symbol_versioning
86
85
from bzrlib.decorators import needs_read_lock, needs_write_lock
87
 
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, TreeReference
88
 
from bzrlib.lockable_files import LockableFiles, TransportLock
 
86
from bzrlib.lockable_files import LockableFiles
89
87
from bzrlib.lockdir import LockDir
90
88
import bzrlib.mutabletree
91
89
from bzrlib.mutabletree import needs_tree_write_lock
 
90
from bzrlib import osutils
92
91
from bzrlib.osutils import (
93
 
    compact_date,
94
92
    file_kind,
95
93
    isdir,
96
94
    normpath,
97
95
    pathjoin,
98
 
    rand_chars,
99
96
    realpath,
100
97
    safe_unicode,
101
98
    splitpath,
102
99
    supports_executable,
103
100
    )
 
101
from bzrlib.filters import filtered_input_file
104
102
from bzrlib.trace import mutter, note
105
103
from bzrlib.transport.local import LocalTransport
106
104
from bzrlib.progress import DummyProgress, ProgressPhase
107
 
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
 
105
from bzrlib.revision import CURRENT_REVISION
108
106
from bzrlib.rio import RioReader, rio_file, Stanza
109
 
from bzrlib.symbol_versioning import (deprecated_passed,
110
 
        deprecated_method,
111
 
        deprecated_function,
112
 
        DEPRECATED_PARAMETER,
113
 
        zero_eight,
114
 
        zero_eleven,
115
 
        zero_thirteen,
116
 
        )
 
107
from bzrlib.symbol_versioning import (
 
108
    deprecated_passed,
 
109
    DEPRECATED_PARAMETER,
 
110
    )
117
111
 
118
112
 
119
113
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
120
114
CONFLICT_HEADER_1 = "BZR conflict list format 1"
121
115
 
122
 
 
123
 
@deprecated_function(zero_thirteen)
124
 
def gen_file_id(name):
125
 
    """Return new file id for the basename 'name'.
126
 
 
127
 
    Use bzrlib.generate_ids.gen_file_id() instead
128
 
    """
129
 
    return generate_ids.gen_file_id(name)
130
 
 
131
 
 
132
 
@deprecated_function(zero_thirteen)
133
 
def gen_root_id():
134
 
    """Return a new tree-root file id.
135
 
 
136
 
    This has been deprecated in favor of bzrlib.generate_ids.gen_root_id()
137
 
    """
138
 
    return generate_ids.gen_root_id()
 
116
ERROR_PATH_NOT_FOUND = 3    # WindowsError errno code, equivalent to ENOENT
139
117
 
140
118
 
141
119
class TreeEntry(object):
142
120
    """An entry that implements the minimum interface used by commands.
143
121
 
144
 
    This needs further inspection, it may be better to have 
 
122
    This needs further inspection, it may be better to have
145
123
    InventoryEntries without ids - though that seems wrong. For now,
146
124
    this is a parallel hierarchy to InventoryEntry, and needs to become
147
125
    one of several things: decorates to that hierarchy, children of, or
150
128
    no InventoryEntry available - i.e. for unversioned objects.
151
129
    Perhaps they should be UnversionedEntry et al. ? - RBC 20051003
152
130
    """
153
 
 
 
131
 
154
132
    def __eq__(self, other):
155
133
        # yes, this us ugly, TODO: best practice __eq__ style.
156
134
        return (isinstance(other, TreeEntry)
157
135
                and other.__class__ == self.__class__)
158
 
 
 
136
 
159
137
    def kind_character(self):
160
138
        return "???"
161
139
 
203
181
    not listed in the Inventory and vice versa.
204
182
    """
205
183
 
 
184
    # override this to set the strategy for storing views
 
185
    def _make_views(self):
 
186
        return views.DisabledViews(self)
 
187
 
206
188
    def __init__(self, basedir='.',
207
189
                 branch=DEPRECATED_PARAMETER,
208
190
                 _inventory=None,
219
201
        if not _internal:
220
202
            raise errors.BzrError("Please use bzrdir.open_workingtree or "
221
203
                "WorkingTree.open() to obtain a WorkingTree.")
222
 
        assert isinstance(basedir, basestring), \
223
 
            "base directory %r is not a string" % basedir
224
204
        basedir = safe_unicode(basedir)
225
205
        mutter("opening working tree %r", basedir)
226
206
        if deprecated_passed(branch):
234
214
            self._control_files = self.branch.control_files
235
215
        else:
236
216
            # assume all other formats have their own control files.
237
 
            assert isinstance(_control_files, LockableFiles), \
238
 
                    "_control_files must be a LockableFiles, not %r" \
239
 
                    % _control_files
240
217
            self._control_files = _control_files
 
218
        self._transport = self._control_files._transport
241
219
        # update the whole cache up front and write to disk if anything changed;
242
220
        # in the future we might want to do this more selectively
243
221
        # two possible ways offer themselves : in self._unlock, write the cache
247
225
        wt_trans = self.bzrdir.get_workingtree_transport(None)
248
226
        cache_filename = wt_trans.local_abspath('stat-cache')
249
227
        self._hashcache = hashcache.HashCache(basedir, cache_filename,
250
 
                                              self._control_files._file_mode)
 
228
            self.bzrdir._get_file_mode(),
 
229
            self._content_filter_stack_provider())
251
230
        hc = self._hashcache
252
231
        hc.read()
253
232
        # is this scan needed ? it makes things kinda slow.
267
246
            # the Format factory and creation methods that are
268
247
            # permitted to do this.
269
248
            self._set_inventory(_inventory, dirty=False)
 
249
        self._detect_case_handling()
 
250
        self._rules_searcher = None
 
251
        self.views = self._make_views()
 
252
 
 
253
    def _detect_case_handling(self):
 
254
        wt_trans = self.bzrdir.get_workingtree_transport(None)
 
255
        try:
 
256
            wt_trans.stat("FoRMaT")
 
257
        except errors.NoSuchFile:
 
258
            self.case_sensitive = True
 
259
        else:
 
260
            self.case_sensitive = False
 
261
 
 
262
        self._setup_directory_is_tree_reference()
270
263
 
271
264
    branch = property(
272
265
        fget=lambda self: self._branch,
287
280
        self._control_files.break_lock()
288
281
        self.branch.break_lock()
289
282
 
 
283
    def _get_check_refs(self):
 
284
        """Return the references needed to perform a check of this tree.
 
285
        
 
286
        The default implementation returns no refs, and is only suitable for
 
287
        trees that have no local caching and can commit on ghosts at any time.
 
288
 
 
289
        :seealso: bzrlib.check for details about check_refs.
 
290
        """
 
291
        return []
 
292
 
290
293
    def requires_rich_root(self):
291
294
        return self._format.requires_rich_root
292
295
 
293
296
    def supports_tree_reference(self):
294
297
        return False
295
298
 
 
299
    def supports_content_filtering(self):
 
300
        return self._format.supports_content_filtering()
 
301
 
 
302
    def supports_views(self):
 
303
        return self.views.supports_views()
 
304
 
296
305
    def _set_inventory(self, inv, dirty):
297
306
        """Set the internal cached inventory.
298
307
 
303
312
            False then the inventory is the same as that on disk and any
304
313
            serialisation would be unneeded overhead.
305
314
        """
306
 
        assert inv.root is not None
307
315
        self._inventory = inv
308
316
        self._inventory_is_modified = dirty
309
317
 
313
321
 
314
322
        """
315
323
        if path is None:
316
 
            path = os.path.getcwdu()
 
324
            path = osutils.getcwd()
317
325
        control = bzrdir.BzrDir.open(path, _unsupported)
318
326
        return control.open_workingtree(_unsupported)
319
 
        
 
327
 
320
328
    @staticmethod
321
329
    def open_containing(path=None):
322
330
        """Open an existing working tree which has its root about path.
323
 
        
 
331
 
324
332
        This probes for a working tree at path and searches upwards from there.
325
333
 
326
334
        Basically we keep looking up until we find the control directory or
344
352
        """
345
353
        return WorkingTree.open(path, _unsupported=True)
346
354
 
 
355
    @staticmethod
 
356
    def find_trees(location):
 
357
        def list_current(transport):
 
358
            return [d for d in transport.list_dir('') if d != '.bzr']
 
359
        def evaluate(bzrdir):
 
360
            try:
 
361
                tree = bzrdir.open_workingtree()
 
362
            except errors.NoWorkingTree:
 
363
                return True, None
 
364
            else:
 
365
                return True, tree
 
366
        transport = get_transport(location)
 
367
        iterator = bzrdir.BzrDir.find_bzrdirs(transport, evaluate=evaluate,
 
368
                                              list_current=list_current)
 
369
        return [t for t in iterator if t is not None]
 
370
 
347
371
    # should be deprecated - this is slow and in any case treating them as a
348
372
    # container is (we now know) bad style -- mbp 20070302
349
373
    ## @deprecated_method(zero_fifteen)
358
382
            if osutils.lexists(self.abspath(path)):
359
383
                yield ie.file_id
360
384
 
 
385
    def all_file_ids(self):
 
386
        """See Tree.iter_all_file_ids"""
 
387
        return set(self.inventory)
 
388
 
361
389
    def __repr__(self):
362
390
        return "<%s of %s>" % (self.__class__.__name__,
363
391
                               getattr(self, 'basedir', None))
364
392
 
365
393
    def abspath(self, filename):
366
394
        return pathjoin(self.basedir, filename)
367
 
    
 
395
 
368
396
    def basis_tree(self):
369
397
        """Return RevisionTree for the current last revision.
370
 
        
 
398
 
371
399
        If the left most parent is a ghost then the returned tree will be an
372
 
        empty tree - one obtained by calling repository.revision_tree(None).
 
400
        empty tree - one obtained by calling
 
401
        repository.revision_tree(NULL_REVISION).
373
402
        """
374
403
        try:
375
404
            revision_id = self.get_parent_ids()[0]
377
406
            # no parents, return an empty revision tree.
378
407
            # in the future this should return the tree for
379
408
            # 'empty:' - the implicit root empty tree.
380
 
            return self.branch.repository.revision_tree(None)
 
409
            return self.branch.repository.revision_tree(
 
410
                       _mod_revision.NULL_REVISION)
381
411
        try:
382
412
            return self.revision_tree(revision_id)
383
413
        except errors.NoSuchRevision:
387
417
        # at this point ?
388
418
        try:
389
419
            return self.branch.repository.revision_tree(revision_id)
390
 
        except errors.RevisionNotPresent:
 
420
        except (errors.RevisionNotPresent, errors.NoSuchRevision):
391
421
            # the basis tree *may* be a ghost or a low level error may have
392
 
            # occured. If the revision is present, its a problem, if its not
 
422
            # occurred. If the revision is present, its a problem, if its not
393
423
            # its a ghost.
394
424
            if self.branch.repository.has_revision(revision_id):
395
425
                raise
396
426
            # the basis tree is a ghost so return an empty tree.
397
 
            return self.branch.repository.revision_tree(None)
398
 
 
399
 
    @staticmethod
400
 
    @deprecated_method(zero_eight)
401
 
    def create(branch, directory):
402
 
        """Create a workingtree for branch at directory.
403
 
 
404
 
        If existing_directory already exists it must have a .bzr directory.
405
 
        If it does not exist, it will be created.
406
 
 
407
 
        This returns a new WorkingTree object for the new checkout.
408
 
 
409
 
        TODO FIXME RBC 20060124 when we have checkout formats in place this
410
 
        should accept an optional revisionid to checkout [and reject this if
411
 
        checking out into the same dir as a pre-checkout-aware branch format.]
412
 
 
413
 
        XXX: When BzrDir is present, these should be created through that 
414
 
        interface instead.
415
 
        """
416
 
        warnings.warn('delete WorkingTree.create', stacklevel=3)
417
 
        transport = get_transport(directory)
418
 
        if branch.bzrdir.root_transport.base == transport.base:
419
 
            # same dir 
420
 
            return branch.bzrdir.create_workingtree()
421
 
        # different directory, 
422
 
        # create a branch reference
423
 
        # and now a working tree.
424
 
        raise NotImplementedError
425
 
 
426
 
    @staticmethod
427
 
    @deprecated_method(zero_eight)
428
 
    def create_standalone(directory):
429
 
        """Create a checkout and a branch and a repo at directory.
430
 
 
431
 
        Directory must exist and be empty.
432
 
 
433
 
        please use BzrDir.create_standalone_workingtree
434
 
        """
435
 
        return bzrdir.BzrDir.create_standalone_workingtree(directory)
 
427
            return self.branch.repository.revision_tree(
 
428
                       _mod_revision.NULL_REVISION)
 
429
 
 
430
    def _cleanup(self):
 
431
        self._flush_ignore_list_cache()
436
432
 
437
433
    def relpath(self, path):
438
434
        """Return the local path portion from a given path.
439
 
        
440
 
        The path may be absolute or relative. If its a relative path it is 
 
435
 
 
436
        The path may be absolute or relative. If its a relative path it is
441
437
        interpreted relative to the python current working directory.
442
438
        """
443
439
        return osutils.relpath(self.basedir, path)
445
441
    def has_filename(self, filename):
446
442
        return osutils.lexists(self.abspath(filename))
447
443
 
448
 
    def get_file(self, file_id):
449
 
        file_id = osutils.safe_file_id(file_id)
450
 
        return self.get_file_byname(self.id2path(file_id))
451
 
 
452
 
    def get_file_text(self, file_id):
453
 
        file_id = osutils.safe_file_id(file_id)
454
 
        return self.get_file(file_id).read()
455
 
 
456
 
    def get_file_byname(self, filename):
457
 
        return file(self.abspath(filename), 'rb')
 
444
    def get_file(self, file_id, path=None, filtered=True):
 
445
        return self.get_file_with_stat(file_id, path, filtered=filtered)[0]
 
446
 
 
447
    def get_file_with_stat(self, file_id, path=None, filtered=True,
 
448
        _fstat=os.fstat):
 
449
        """See Tree.get_file_with_stat."""
 
450
        if path is None:
 
451
            path = self.id2path(file_id)
 
452
        file_obj = self.get_file_byname(path, filtered=False)
 
453
        stat_value = _fstat(file_obj.fileno())
 
454
        if filtered and self.supports_content_filtering():
 
455
            filters = self._content_filter_stack(path)
 
456
            file_obj = filtered_input_file(file_obj, filters)
 
457
        return (file_obj, stat_value)
 
458
 
 
459
    def get_file_text(self, file_id, path=None, filtered=True):
 
460
        return self.get_file(file_id, path=path, filtered=filtered).read()
 
461
 
 
462
    def get_file_byname(self, filename, filtered=True):
 
463
        path = self.abspath(filename)
 
464
        f = file(path, 'rb')
 
465
        if filtered and self.supports_content_filtering():
 
466
            filters = self._content_filter_stack(filename)
 
467
            return filtered_input_file(f, filters)
 
468
        else:
 
469
            return f
 
470
 
 
471
    def get_file_lines(self, file_id, path=None, filtered=True):
 
472
        """See Tree.get_file_lines()"""
 
473
        file = self.get_file(file_id, path, filtered=filtered)
 
474
        try:
 
475
            return file.readlines()
 
476
        finally:
 
477
            file.close()
458
478
 
459
479
    @needs_read_lock
460
 
    def annotate_iter(self, file_id):
 
480
    def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
461
481
        """See Tree.annotate_iter
462
482
 
463
483
        This implementation will use the basis tree implementation if possible.
467
487
        incorrectly attributed to CURRENT_REVISION (but after committing, the
468
488
        attribution will be correct).
469
489
        """
470
 
        file_id = osutils.safe_file_id(file_id)
471
 
        basis = self.basis_tree()
472
 
        basis.lock_read()
473
 
        try:
474
 
            changes = self._iter_changes(basis, True, [self.id2path(file_id)],
475
 
                require_versioned=True).next()
476
 
            changed_content, kind = changes[2], changes[6]
477
 
            if not changed_content:
478
 
                return basis.annotate_iter(file_id)
479
 
            if kind[1] is None:
480
 
                return None
481
 
            import annotate
482
 
            if kind[0] != 'file':
483
 
                old_lines = []
484
 
            else:
485
 
                old_lines = list(basis.annotate_iter(file_id))
486
 
            old = [old_lines]
487
 
            for tree in self.branch.repository.revision_trees(
488
 
                self.get_parent_ids()[1:]):
489
 
                if file_id not in tree:
490
 
                    continue
491
 
                old.append(list(tree.annotate_iter(file_id)))
492
 
            return annotate.reannotate(old, self.get_file(file_id).readlines(),
493
 
                                       CURRENT_REVISION)
494
 
        finally:
495
 
            basis.unlock()
 
490
        maybe_file_parent_keys = []
 
491
        for parent_id in self.get_parent_ids():
 
492
            try:
 
493
                parent_tree = self.revision_tree(parent_id)
 
494
            except errors.NoSuchRevisionInTree:
 
495
                parent_tree = self.branch.repository.revision_tree(parent_id)
 
496
            parent_tree.lock_read()
 
497
            try:
 
498
                if file_id not in parent_tree:
 
499
                    continue
 
500
                ie = parent_tree.inventory[file_id]
 
501
                if ie.kind != 'file':
 
502
                    # Note: this is slightly unnecessary, because symlinks and
 
503
                    # directories have a "text" which is the empty text, and we
 
504
                    # know that won't mess up annotations. But it seems cleaner
 
505
                    continue
 
506
                parent_text_key = (file_id, ie.revision)
 
507
                if parent_text_key not in maybe_file_parent_keys:
 
508
                    maybe_file_parent_keys.append(parent_text_key)
 
509
            finally:
 
510
                parent_tree.unlock()
 
511
        graph = _mod_graph.Graph(self.branch.repository.texts)
 
512
        heads = graph.heads(maybe_file_parent_keys)
 
513
        file_parent_keys = []
 
514
        for key in maybe_file_parent_keys:
 
515
            if key in heads:
 
516
                file_parent_keys.append(key)
 
517
 
 
518
        # Now we have the parents of this content
 
519
        annotator = self.branch.repository.texts.get_annotator()
 
520
        text = self.get_file(file_id).read()
 
521
        this_key =(file_id, default_revision)
 
522
        annotator.add_special_text(this_key, file_parent_keys, text)
 
523
        annotations = [(key[-1], line)
 
524
                       for key, line in annotator.annotate_flat(this_key)]
 
525
        return annotations
 
526
 
 
527
    def _get_ancestors(self, default_revision):
 
528
        ancestors = set([default_revision])
 
529
        for parent_id in self.get_parent_ids():
 
530
            ancestors.update(self.branch.repository.get_ancestry(
 
531
                             parent_id, topo_sorted=False))
 
532
        return ancestors
496
533
 
497
534
    def get_parent_ids(self):
498
535
        """See Tree.get_parent_ids.
499
 
        
 
536
 
500
537
        This implementation reads the pending merges list and last_revision
501
538
        value and uses that to decide what the parents list should be.
502
539
        """
503
 
        last_rev = self._last_revision()
504
 
        if last_rev is None:
 
540
        last_rev = _mod_revision.ensure_null(self._last_revision())
 
541
        if _mod_revision.NULL_REVISION == last_rev:
505
542
            parents = []
506
543
        else:
507
544
            parents = [last_rev]
508
545
        try:
509
 
            merges_file = self._control_files.get('pending-merges')
 
546
            merges_bytes = self._transport.get_bytes('pending-merges')
510
547
        except errors.NoSuchFile:
511
548
            pass
512
549
        else:
513
 
            for l in merges_file.readlines():
514
 
                revision_id = osutils.safe_revision_id(l.rstrip('\n'))
 
550
            for l in osutils.split_lines(merges_bytes):
 
551
                revision_id = l.rstrip('\n')
515
552
                parents.append(revision_id)
516
553
        return parents
517
554
 
519
556
    def get_root_id(self):
520
557
        """Return the id of this trees root"""
521
558
        return self._inventory.root.file_id
522
 
        
 
559
 
523
560
    def _get_store_filename(self, file_id):
524
561
        ## XXX: badly named; this is not in the store at all
525
 
        file_id = osutils.safe_file_id(file_id)
526
562
        return self.abspath(self.id2path(file_id))
527
563
 
528
564
    @needs_read_lock
529
565
    def clone(self, to_bzrdir, revision_id=None):
530
566
        """Duplicate this working tree into to_bzr, including all state.
531
 
        
 
567
 
532
568
        Specifically modified files are kept as modified, but
533
569
        ignored and unknown files are discarded.
534
570
 
535
571
        If you want to make a new line of development, see bzrdir.sprout()
536
572
 
537
573
        revision
538
 
            If not None, the cloned tree will have its last revision set to 
539
 
            revision, and and difference between the source trees last revision
 
574
            If not None, the cloned tree will have its last revision set to
 
575
            revision, and difference between the source trees last revision
540
576
            and this one merged in.
541
577
        """
542
578
        # assumes the target bzr dir format is compatible.
543
 
        result = self._format.initialize(to_bzrdir)
 
579
        result = to_bzrdir.create_workingtree()
544
580
        self.copy_content_into(result, revision_id)
545
581
        return result
546
582
 
557
593
            tree.set_parent_ids([revision_id])
558
594
 
559
595
    def id2abspath(self, file_id):
560
 
        file_id = osutils.safe_file_id(file_id)
561
596
        return self.abspath(self.id2path(file_id))
562
597
 
563
598
    def has_id(self, file_id):
564
599
        # files that have been deleted are excluded
565
 
        file_id = osutils.safe_file_id(file_id)
566
600
        inv = self.inventory
567
601
        if not inv.has_id(file_id):
568
602
            return False
570
604
        return osutils.lexists(self.abspath(path))
571
605
 
572
606
    def has_or_had_id(self, file_id):
573
 
        file_id = osutils.safe_file_id(file_id)
574
607
        if file_id == self.inventory.root.file_id:
575
608
            return True
576
609
        return self.inventory.has_id(file_id)
578
611
    __contains__ = has_id
579
612
 
580
613
    def get_file_size(self, file_id):
581
 
        file_id = osutils.safe_file_id(file_id)
582
 
        return os.path.getsize(self.id2abspath(file_id))
 
614
        """See Tree.get_file_size"""
 
615
        # XXX: this returns the on-disk size; it should probably return the
 
616
        # canonical size
 
617
        try:
 
618
            return os.path.getsize(self.id2abspath(file_id))
 
619
        except OSError, e:
 
620
            if e.errno != errno.ENOENT:
 
621
                raise
 
622
            else:
 
623
                return None
583
624
 
584
625
    @needs_read_lock
585
626
    def get_file_sha1(self, file_id, path=None, stat_value=None):
586
 
        file_id = osutils.safe_file_id(file_id)
587
627
        if not path:
588
628
            path = self._inventory.id2path(file_id)
589
629
        return self._hashcache.get_sha1(path, stat_value)
590
630
 
591
631
    def get_file_mtime(self, file_id, path=None):
592
 
        file_id = osutils.safe_file_id(file_id)
593
632
        if not path:
594
633
            path = self.inventory.id2path(file_id)
595
634
        return os.lstat(self.abspath(path)).st_mtime
596
635
 
 
636
    def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
 
637
        file_id = self.path2id(path)
 
638
        if file_id is None:
 
639
            # For unversioned files on win32, we just assume they are not
 
640
            # executable
 
641
            return False
 
642
        return self._inventory[file_id].executable
 
643
 
 
644
    def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
 
645
        mode = stat_result.st_mode
 
646
        return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
647
 
597
648
    if not supports_executable():
598
649
        def is_executable(self, file_id, path=None):
599
 
            file_id = osutils.safe_file_id(file_id)
600
650
            return self._inventory[file_id].executable
 
651
 
 
652
        _is_executable_from_path_and_stat = \
 
653
            _is_executable_from_path_and_stat_from_basis
601
654
    else:
602
655
        def is_executable(self, file_id, path=None):
603
656
            if not path:
604
 
                file_id = osutils.safe_file_id(file_id)
605
657
                path = self.id2path(file_id)
606
658
            mode = os.lstat(self.abspath(path)).st_mode
607
659
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
608
660
 
 
661
        _is_executable_from_path_and_stat = \
 
662
            _is_executable_from_path_and_stat_from_stat
 
663
 
609
664
    @needs_tree_write_lock
610
665
    def _add(self, files, ids, kinds):
611
666
        """See MutableTree._add."""
612
667
        # TODO: Re-adding a file that is removed in the working copy
613
668
        # should probably put it back with the previous ID.
614
 
        # the read and write working inventory should not occur in this 
 
669
        # the read and write working inventory should not occur in this
615
670
        # function - they should be part of lock_write and unlock.
616
 
        inv = self.read_working_inventory()
 
671
        inv = self.inventory
617
672
        for f, file_id, kind in zip(files, ids, kinds):
618
 
            assert kind is not None
619
673
            if file_id is None:
620
674
                inv.add_path(f, kind=kind)
621
675
            else:
622
 
                file_id = osutils.safe_file_id(file_id)
623
676
                inv.add_path(f, kind=kind, file_id=file_id)
624
 
        self._write_inventory(inv)
 
677
            self._inventory_is_modified = True
625
678
 
626
679
    @needs_tree_write_lock
627
680
    def _gather_kinds(self, files, kinds):
687
740
        if updated:
688
741
            self.set_parent_ids(parents, allow_leftmost_as_ghost=True)
689
742
 
690
 
    @deprecated_method(zero_eleven)
691
 
    @needs_read_lock
692
 
    def pending_merges(self):
693
 
        """Return a list of pending merges.
694
 
 
695
 
        These are revisions that have been merged into the working
696
 
        directory but not yet committed.
697
 
 
698
 
        As of 0.11 this is deprecated. Please see WorkingTree.get_parent_ids()
699
 
        instead - which is available on all tree objects.
700
 
        """
701
 
        return self.get_parent_ids()[1:]
 
743
    def path_content_summary(self, path, _lstat=os.lstat,
 
744
        _mapper=osutils.file_kind_from_stat_mode):
 
745
        """See Tree.path_content_summary."""
 
746
        abspath = self.abspath(path)
 
747
        try:
 
748
            stat_result = _lstat(abspath)
 
749
        except OSError, e:
 
750
            if getattr(e, 'errno', None) == errno.ENOENT:
 
751
                # no file.
 
752
                return ('missing', None, None, None)
 
753
            # propagate other errors
 
754
            raise
 
755
        kind = _mapper(stat_result.st_mode)
 
756
        if kind == 'file':
 
757
            return self._file_content_summary(path, stat_result)
 
758
        elif kind == 'directory':
 
759
            # perhaps it looks like a plain directory, but it's really a
 
760
            # reference.
 
761
            if self._directory_is_tree_reference(path):
 
762
                kind = 'tree-reference'
 
763
            return kind, None, None, None
 
764
        elif kind == 'symlink':
 
765
            target = osutils.readlink(abspath)
 
766
            return ('symlink', None, None, target)
 
767
        else:
 
768
            return (kind, None, None, None)
 
769
 
 
770
    def _file_content_summary(self, path, stat_result):
 
771
        size = stat_result.st_size
 
772
        executable = self._is_executable_from_path_and_stat(path, stat_result)
 
773
        # try for a stat cache lookup
 
774
        return ('file', size, executable, self._sha_from_stat(
 
775
            path, stat_result))
702
776
 
703
777
    def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):
704
778
        """Common ghost checking functionality from set_parent_*.
714
788
 
715
789
    def _set_merges_from_parent_ids(self, parent_ids):
716
790
        merges = parent_ids[1:]
717
 
        self._control_files.put_bytes('pending-merges', '\n'.join(merges))
 
791
        self._transport.put_bytes('pending-merges', '\n'.join(merges),
 
792
            mode=self.bzrdir._get_file_mode())
 
793
 
 
794
    def _filter_parent_ids_by_ancestry(self, revision_ids):
 
795
        """Check that all merged revisions are proper 'heads'.
 
796
 
 
797
        This will always return the first revision_id, and any merged revisions
 
798
        which are
 
799
        """
 
800
        if len(revision_ids) == 0:
 
801
            return revision_ids
 
802
        graph = self.branch.repository.get_graph()
 
803
        heads = graph.heads(revision_ids)
 
804
        new_revision_ids = revision_ids[:1]
 
805
        for revision_id in revision_ids[1:]:
 
806
            if revision_id in heads and revision_id not in new_revision_ids:
 
807
                new_revision_ids.append(revision_id)
 
808
        if new_revision_ids != revision_ids:
 
809
            trace.mutter('requested to set revision_ids = %s,'
 
810
                         ' but filtered to %s', revision_ids, new_revision_ids)
 
811
        return new_revision_ids
718
812
 
719
813
    @needs_tree_write_lock
720
814
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
721
815
        """Set the parent ids to revision_ids.
722
 
        
 
816
 
723
817
        See also set_parent_trees. This api will try to retrieve the tree data
724
818
        for each element of revision_ids from the trees repository. If you have
725
819
        tree data already available, it is more efficient to use
729
823
        :param revision_ids: The revision_ids to set as the parent ids of this
730
824
            working tree. Any of these may be ghosts.
731
825
        """
732
 
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
733
826
        self._check_parents_for_ghosts(revision_ids,
734
827
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
828
        for revision_id in revision_ids:
 
829
            _mod_revision.check_not_reserved_id(revision_id)
 
830
 
 
831
        revision_ids = self._filter_parent_ids_by_ancestry(revision_ids)
735
832
 
736
833
        if len(revision_ids) > 0:
737
834
            self.set_last_revision(revision_ids[0])
738
835
        else:
739
 
            self.set_last_revision(None)
 
836
            self.set_last_revision(_mod_revision.NULL_REVISION)
740
837
 
741
838
        self._set_merges_from_parent_ids(revision_ids)
742
839
 
743
840
    @needs_tree_write_lock
744
841
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
745
842
        """See MutableTree.set_parent_trees."""
746
 
        parent_ids = [osutils.safe_revision_id(rev) for (rev, tree) in parents_list]
 
843
        parent_ids = [rev for (rev, tree) in parents_list]
 
844
        for revision_id in parent_ids:
 
845
            _mod_revision.check_not_reserved_id(revision_id)
747
846
 
748
847
        self._check_parents_for_ghosts(parent_ids,
749
848
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
750
849
 
 
850
        parent_ids = self._filter_parent_ids_by_ancestry(parent_ids)
 
851
 
751
852
        if len(parent_ids) == 0:
752
 
            leftmost_parent_id = None
 
853
            leftmost_parent_id = _mod_revision.NULL_REVISION
753
854
            leftmost_parent_tree = None
754
855
        else:
755
856
            leftmost_parent_id, leftmost_parent_tree = parents_list[0]
780
881
                yield Stanza(file_id=file_id.decode('utf8'), hash=hash)
781
882
        self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
782
883
 
 
884
    def _sha_from_stat(self, path, stat_result):
 
885
        """Get a sha digest from the tree's stat cache.
 
886
 
 
887
        The default implementation assumes no stat cache is present.
 
888
 
 
889
        :param path: The path.
 
890
        :param stat_result: The stat result being looked up.
 
891
        """
 
892
        return None
 
893
 
783
894
    def _put_rio(self, filename, stanzas, header):
784
895
        self._must_be_locked()
785
896
        my_file = rio_file(stanzas, header)
786
 
        self._control_files.put(filename, my_file)
 
897
        self._transport.put_file(filename, my_file,
 
898
            mode=self.bzrdir._get_file_mode())
787
899
 
788
900
    @needs_write_lock # because merge pulls data into the branch.
789
 
    def merge_from_branch(self, branch, to_revision=None):
 
901
    def merge_from_branch(self, branch, to_revision=None, from_revision=None,
 
902
                          merge_type=None, force=False):
790
903
        """Merge from a branch into this working tree.
791
904
 
792
905
        :param branch: The branch to merge from.
796
909
            branch.last_revision().
797
910
        """
798
911
        from bzrlib.merge import Merger, Merge3Merger
799
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
912
        pb = ui.ui_factory.nested_progress_bar()
800
913
        try:
801
914
            merger = Merger(self.branch, this_tree=self, pb=pb)
802
915
            merger.pp = ProgressPhase("Merge phase", 5, pb)
803
916
            merger.pp.next_phase()
804
 
            # check that there are no
805
 
            # local alterations
806
 
            merger.check_basis(check_clean=True, require_commits=False)
 
917
            # check that there are no local alterations
 
918
            if not force and self.has_changes():
 
919
                raise errors.UncommittedChanges(self)
807
920
            if to_revision is None:
808
 
                to_revision = branch.last_revision()
809
 
            else:
810
 
                to_revision = osutils.safe_revision_id(to_revision)
 
921
                to_revision = _mod_revision.ensure_null(branch.last_revision())
811
922
            merger.other_rev_id = to_revision
812
 
            if merger.other_rev_id is None:
813
 
                raise error.NoCommits(branch)
 
923
            if _mod_revision.is_null(merger.other_rev_id):
 
924
                raise errors.NoCommits(branch)
814
925
            self.branch.fetch(branch, last_revision=merger.other_rev_id)
815
926
            merger.other_basis = merger.other_rev_id
816
927
            merger.other_tree = self.branch.repository.revision_tree(
817
928
                merger.other_rev_id)
818
929
            merger.other_branch = branch
819
930
            merger.pp.next_phase()
820
 
            merger.find_base()
 
931
            if from_revision is None:
 
932
                merger.find_base()
 
933
            else:
 
934
                merger.set_base_revision(from_revision, branch)
821
935
            if merger.base_rev_id == merger.other_rev_id:
822
936
                raise errors.PointlessMerge
823
937
            merger.backup_files = False
824
 
            merger.merge_type = Merge3Merger
 
938
            if merge_type is None:
 
939
                merger.merge_type = Merge3Merger
 
940
            else:
 
941
                merger.merge_type = merge_type
825
942
            merger.set_interesting_files(None)
826
943
            merger.show_base = False
827
944
            merger.reprocess = False
835
952
    def merge_modified(self):
836
953
        """Return a dictionary of files modified by a merge.
837
954
 
838
 
        The list is initialized by WorkingTree.set_merge_modified, which is 
 
955
        The list is initialized by WorkingTree.set_merge_modified, which is
839
956
        typically called after we make some automatic updates to the tree
840
957
        because of a merge.
841
958
 
843
960
        still in the working inventory and have that text hash.
844
961
        """
845
962
        try:
846
 
            hashfile = self._control_files.get('merge-hashes')
 
963
            hashfile = self._transport.get('merge-hashes')
847
964
        except errors.NoSuchFile:
848
965
            return {}
849
 
        merge_hashes = {}
850
966
        try:
851
 
            if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
 
967
            merge_hashes = {}
 
968
            try:
 
969
                if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
 
970
                    raise errors.MergeModifiedFormatError()
 
971
            except StopIteration:
852
972
                raise errors.MergeModifiedFormatError()
853
 
        except StopIteration:
854
 
            raise errors.MergeModifiedFormatError()
855
 
        for s in RioReader(hashfile):
856
 
            # RioReader reads in Unicode, so convert file_ids back to utf8
857
 
            file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
858
 
            if file_id not in self.inventory:
859
 
                continue
860
 
            text_hash = s.get("hash")
861
 
            if text_hash == self.get_file_sha1(file_id):
862
 
                merge_hashes[file_id] = text_hash
863
 
        return merge_hashes
 
973
            for s in RioReader(hashfile):
 
974
                # RioReader reads in Unicode, so convert file_ids back to utf8
 
975
                file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
 
976
                if file_id not in self.inventory:
 
977
                    continue
 
978
                text_hash = s.get("hash")
 
979
                if text_hash == self.get_file_sha1(file_id):
 
980
                    merge_hashes[file_id] = text_hash
 
981
            return merge_hashes
 
982
        finally:
 
983
            hashfile.close()
864
984
 
865
985
    @needs_write_lock
866
986
    def mkdir(self, path, file_id=None):
872
992
        return file_id
873
993
 
874
994
    def get_symlink_target(self, file_id):
875
 
        file_id = osutils.safe_file_id(file_id)
876
 
        return os.readlink(self.id2abspath(file_id))
 
995
        abspath = self.id2abspath(file_id)
 
996
        target = osutils.readlink(abspath)
 
997
        return target
877
998
 
878
999
    @needs_write_lock
879
1000
    def subsume(self, other_tree):
917
1038
            other_tree.unlock()
918
1039
        other_tree.bzrdir.retire_bzrdir()
919
1040
 
 
1041
    def _setup_directory_is_tree_reference(self):
 
1042
        if self._branch.repository._format.supports_tree_reference:
 
1043
            self._directory_is_tree_reference = \
 
1044
                self._directory_may_be_tree_reference
 
1045
        else:
 
1046
            self._directory_is_tree_reference = \
 
1047
                self._directory_is_never_tree_reference
 
1048
 
 
1049
    def _directory_is_never_tree_reference(self, relpath):
 
1050
        return False
 
1051
 
 
1052
    def _directory_may_be_tree_reference(self, relpath):
 
1053
        # as a special case, if a directory contains control files then
 
1054
        # it's a tree reference, except that the root of the tree is not
 
1055
        return relpath and osutils.isdir(self.abspath(relpath) + u"/.bzr")
 
1056
        # TODO: We could ask all the control formats whether they
 
1057
        # recognize this directory, but at the moment there's no cheap api
 
1058
        # to do that.  Since we probably can only nest bzr checkouts and
 
1059
        # they always use this name it's ok for now.  -- mbp 20060306
 
1060
        #
 
1061
        # FIXME: There is an unhandled case here of a subdirectory
 
1062
        # containing .bzr but not a branch; that will probably blow up
 
1063
        # when you try to commit it.  It might happen if there is a
 
1064
        # checkout in a subdirectory.  This can be avoided by not adding
 
1065
        # it.  mbp 20070306
 
1066
 
920
1067
    @needs_tree_write_lock
921
1068
    def extract(self, file_id, format=None):
922
1069
        """Extract a subtree from this tree.
923
 
        
 
1070
 
924
1071
        A new branch will be created, relative to the path for this tree.
925
1072
        """
926
1073
        self.flush()
929
1076
            transport = self.branch.bzrdir.root_transport
930
1077
            for name in segments:
931
1078
                transport = transport.clone(name)
932
 
                try:
933
 
                    transport.mkdir('.')
934
 
                except errors.FileExists:
935
 
                    pass
 
1079
                transport.ensure_base()
936
1080
            return transport
937
 
            
 
1081
 
938
1082
        sub_path = self.id2path(file_id)
939
1083
        branch_transport = mkdirs(sub_path)
940
1084
        if format is None:
941
 
            format = bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
942
 
        try:
943
 
            branch_transport.mkdir('.')
944
 
        except errors.FileExists:
945
 
            pass
 
1085
            format = self.bzrdir.cloning_metadir()
 
1086
        branch_transport.ensure_base()
946
1087
        branch_bzrdir = format.initialize_on_transport(branch_transport)
947
1088
        try:
948
1089
            repo = branch_bzrdir.find_repository()
949
1090
        except errors.NoRepositoryPresent:
950
1091
            repo = branch_bzrdir.create_repository()
951
 
            assert repo.supports_rich_root()
952
 
        else:
953
 
            if not repo.supports_rich_root():
954
 
                raise errors.RootNotRich()
 
1092
        if not repo.supports_rich_root():
 
1093
            raise errors.RootNotRich()
955
1094
        new_branch = branch_bzrdir.create_branch()
956
1095
        new_branch.pull(self.branch)
957
1096
        for parent_id in self.get_parent_ids():
962
1101
            branch.BranchReferenceFormat().initialize(tree_bzrdir, new_branch)
963
1102
        else:
964
1103
            tree_bzrdir = branch_bzrdir
965
 
        wt = tree_bzrdir.create_workingtree(NULL_REVISION)
 
1104
        wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
966
1105
        wt.set_parent_ids(self.get_parent_ids())
967
1106
        my_inv = self.inventory
968
 
        child_inv = Inventory(root_id=None)
 
1107
        child_inv = inventory.Inventory(root_id=None)
969
1108
        new_root = my_inv[file_id]
970
1109
        my_inv.remove_recursive_id(file_id)
971
1110
        new_root.parent_id = None
975
1114
        return wt
976
1115
 
977
1116
    def _serialize(self, inventory, out_file):
978
 
        xml5.serializer_v5.write_inventory(self._inventory, out_file)
 
1117
        xml5.serializer_v5.write_inventory(self._inventory, out_file,
 
1118
            working=True)
979
1119
 
980
1120
    def _deserialize(selt, in_file):
981
1121
        return xml5.serializer_v5.read_inventory(in_file)
988
1128
        sio = StringIO()
989
1129
        self._serialize(self._inventory, sio)
990
1130
        sio.seek(0)
991
 
        self._control_files.put('inventory', sio)
 
1131
        self._transport.put_file('inventory', sio,
 
1132
            mode=self.bzrdir._get_file_mode())
992
1133
        self._inventory_is_modified = False
993
1134
 
994
1135
    def _kind(self, relpath):
995
1136
        return osutils.file_kind(self.abspath(relpath))
996
1137
 
997
 
    def list_files(self, include_root=False):
998
 
        """Recursively list all files as (path, class, kind, id, entry).
 
1138
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
1139
        """List all files as (path, class, kind, id, entry).
999
1140
 
1000
1141
        Lists, but does not descend into unversioned directories.
1001
 
 
1002
1142
        This does not include files that have been deleted in this
1003
 
        tree.
 
1143
        tree. Skips the control directory.
1004
1144
 
1005
 
        Skips the control directory.
 
1145
        :param include_root: if True, do not return an entry for the root
 
1146
        :param from_dir: start from this directory or None for the root
 
1147
        :param recursive: whether to recurse into subdirectories or not
1006
1148
        """
1007
1149
        # list_files is an iterator, so @needs_read_lock doesn't work properly
1008
1150
        # with it. So callers should be careful to always read_lock the tree.
1010
1152
            raise errors.ObjectNotLocked(self)
1011
1153
 
1012
1154
        inv = self.inventory
1013
 
        if include_root is True:
 
1155
        if from_dir is None and include_root is True:
1014
1156
            yield ('', 'V', 'directory', inv.root.file_id, inv.root)
1015
1157
        # Convert these into local objects to save lookup times
1016
1158
        pathjoin = osutils.pathjoin
1023
1165
        fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
1024
1166
 
1025
1167
        # directory file_id, relative path, absolute path, reverse sorted children
1026
 
        children = os.listdir(self.basedir)
 
1168
        if from_dir is not None:
 
1169
            from_dir_id = inv.path2id(from_dir)
 
1170
            if from_dir_id is None:
 
1171
                # Directory not versioned
 
1172
                return
 
1173
            from_dir_abspath = pathjoin(self.basedir, from_dir)
 
1174
        else:
 
1175
            from_dir_id = inv.root.file_id
 
1176
            from_dir_abspath = self.basedir
 
1177
        children = os.listdir(from_dir_abspath)
1027
1178
        children.sort()
1028
 
        # jam 20060527 The kernel sized tree seems equivalent whether we 
 
1179
        # jam 20060527 The kernel sized tree seems equivalent whether we
1029
1180
        # use a deque and popleft to keep them sorted, or if we use a plain
1030
1181
        # list and just reverse() them.
1031
1182
        children = collections.deque(children)
1032
 
        stack = [(inv.root.file_id, u'', self.basedir, children)]
 
1183
        stack = [(from_dir_id, u'', from_dir_abspath, children)]
1033
1184
        while stack:
1034
1185
            from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
1035
1186
 
1051
1202
 
1052
1203
                # absolute path
1053
1204
                fap = from_dir_abspath + '/' + f
1054
 
                
 
1205
 
1055
1206
                f_ie = inv.get_child(from_dir_id, f)
1056
1207
                if f_ie:
1057
1208
                    c = 'V'
1089
1240
                    except KeyError:
1090
1241
                        yield fp[1:], c, fk, None, TreeEntry()
1091
1242
                    continue
1092
 
                
 
1243
 
1093
1244
                if fk != 'directory':
1094
1245
                    continue
1095
1246
 
1096
 
                # But do this child first
1097
 
                new_children = os.listdir(fap)
1098
 
                new_children.sort()
1099
 
                new_children = collections.deque(new_children)
1100
 
                stack.append((f_ie.file_id, fp, fap, new_children))
1101
 
                # Break out of inner loop,
1102
 
                # so that we start outer loop with child
1103
 
                break
 
1247
                # But do this child first if recursing down
 
1248
                if recursive:
 
1249
                    new_children = os.listdir(fap)
 
1250
                    new_children.sort()
 
1251
                    new_children = collections.deque(new_children)
 
1252
                    stack.append((f_ie.file_id, fp, fap, new_children))
 
1253
                    # Break out of inner loop,
 
1254
                    # so that we start outer loop with child
 
1255
                    break
1104
1256
            else:
1105
1257
                # if we finished all children, pop it off the stack
1106
1258
                stack.pop()
1112
1264
        to_dir must exist in the inventory.
1113
1265
 
1114
1266
        If to_dir exists and is a directory, the files are moved into
1115
 
        it, keeping their old names.  
 
1267
        it, keeping their old names.
1116
1268
 
1117
1269
        Note that to_dir is only the last component of the new name;
1118
1270
        this doesn't change the directory.
1155
1307
                                       DeprecationWarning)
1156
1308
 
1157
1309
        # check destination directory
1158
 
        assert not isinstance(from_paths, basestring)
 
1310
        if isinstance(from_paths, basestring):
 
1311
            raise ValueError()
1159
1312
        inv = self.inventory
1160
1313
        to_abs = self.abspath(to_dir)
1161
1314
        if not isdir(to_abs):
1245
1398
                only_change_inv = True
1246
1399
            elif self.has_filename(from_rel) and not self.has_filename(to_rel):
1247
1400
                only_change_inv = False
 
1401
            elif (not self.case_sensitive
 
1402
                  and from_rel.lower() == to_rel.lower()
 
1403
                  and self.has_filename(from_rel)):
 
1404
                only_change_inv = False
1248
1405
            else:
1249
1406
                # something is wrong, so lets determine what exactly
1250
1407
                if not self.has_filename(from_rel) and \
1253
1410
                        errors.PathsDoNotExist(paths=(str(from_rel),
1254
1411
                        str(to_rel))))
1255
1412
                else:
1256
 
                    raise errors.RenameFailedFilesExist(from_rel, to_rel,
1257
 
                        extra="(Use --after to update the Bazaar id)")
 
1413
                    raise errors.RenameFailedFilesExist(from_rel, to_rel)
1258
1414
            rename_entry.only_change_inv = only_change_inv
1259
1415
        return rename_entries
1260
1416
 
1280
1436
        inv = self.inventory
1281
1437
        for entry in moved:
1282
1438
            try:
1283
 
                self._move_entry(_RenameEntry(entry.to_rel, entry.from_id,
 
1439
                self._move_entry(WorkingTree._RenameEntry(
 
1440
                    entry.to_rel, entry.from_id,
1284
1441
                    entry.to_tail, entry.to_parent_id, entry.from_rel,
1285
1442
                    entry.from_tail, entry.from_parent_id,
1286
1443
                    entry.only_change_inv))
1337
1494
        from_tail = splitpath(from_rel)[-1]
1338
1495
        from_id = inv.path2id(from_rel)
1339
1496
        if from_id is None:
1340
 
            raise errors.BzrRenameFailedError(from_rel,to_rel,
1341
 
                errors.NotVersionedError(path=str(from_rel)))
1342
 
        from_entry = inv[from_id]
 
1497
            # if file is missing in the inventory maybe it's in the basis_tree
 
1498
            basis_tree = self.branch.basis_tree()
 
1499
            from_id = basis_tree.path2id(from_rel)
 
1500
            if from_id is None:
 
1501
                raise errors.BzrRenameFailedError(from_rel,to_rel,
 
1502
                    errors.NotVersionedError(path=str(from_rel)))
 
1503
            # put entry back in the inventory so we can rename it
 
1504
            from_entry = basis_tree.inventory[from_id].copy()
 
1505
            inv.add(from_entry)
 
1506
        else:
 
1507
            from_entry = inv[from_id]
1343
1508
        from_parent_id = from_entry.parent_id
1344
1509
        to_dir, to_tail = os.path.split(to_rel)
1345
1510
        to_dir_id = inv.path2id(to_dir)
1391
1556
        These are files in the working directory that are not versioned or
1392
1557
        control files or ignored.
1393
1558
        """
1394
 
        # force the extras method to be fully executed before returning, to 
 
1559
        # force the extras method to be fully executed before returning, to
1395
1560
        # prevent race conditions with the lock
1396
1561
        return iter(
1397
1562
            [subp for subp in self.extras() if not self.is_ignored(subp)])
1407
1572
        :raises: NoSuchId if any fileid is not currently versioned.
1408
1573
        """
1409
1574
        for file_id in file_ids:
1410
 
            file_id = osutils.safe_file_id(file_id)
 
1575
            if file_id not in self._inventory:
 
1576
                raise errors.NoSuchId(self, file_id)
 
1577
        for file_id in file_ids:
1411
1578
            if self._inventory.has_id(file_id):
1412
1579
                self._inventory.remove_recursive_id(file_id)
1413
 
            else:
1414
 
                raise errors.NoSuchId(self, file_id)
1415
1580
        if len(file_ids):
1416
 
            # in the future this should just set a dirty bit to wait for the 
 
1581
            # in the future this should just set a dirty bit to wait for the
1417
1582
            # final unlock. However, until all methods of workingtree start
1418
 
            # with the current in -memory inventory rather than triggering 
 
1583
            # with the current in -memory inventory rather than triggering
1419
1584
            # a read, it is more complex - we need to teach read_inventory
1420
1585
            # to know when to read, and when to not read first... and possibly
1421
1586
            # to save first when the in memory one may be corrupted.
1422
1587
            # so for now, we just only write it if it is indeed dirty.
1423
1588
            # - RBC 20060907
1424
1589
            self._write_inventory(self._inventory)
1425
 
    
1426
 
    @deprecated_method(zero_eight)
1427
 
    def iter_conflicts(self):
1428
 
        """List all files in the tree that have text or content conflicts.
1429
 
        DEPRECATED.  Use conflicts instead."""
1430
 
        return self._iter_conflicts()
1431
1590
 
1432
1591
    def _iter_conflicts(self):
1433
1592
        conflicted = set()
1442
1601
 
1443
1602
    @needs_write_lock
1444
1603
    def pull(self, source, overwrite=False, stop_revision=None,
1445
 
             change_reporter=None):
1446
 
        top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1604
             change_reporter=None, possible_transports=None, local=False):
 
1605
        top_pb = ui.ui_factory.nested_progress_bar()
1447
1606
        source.lock_read()
1448
1607
        try:
1449
1608
            pp = ProgressPhase("Pull phase", 2, top_pb)
1450
1609
            pp.next_phase()
1451
1610
            old_revision_info = self.branch.last_revision_info()
1452
1611
            basis_tree = self.basis_tree()
1453
 
            count = self.branch.pull(source, overwrite, stop_revision)
 
1612
            count = self.branch.pull(source, overwrite, stop_revision,
 
1613
                                     possible_transports=possible_transports,
 
1614
                                     local=local)
1454
1615
            new_revision_info = self.branch.last_revision_info()
1455
1616
            if new_revision_info != old_revision_info:
1456
1617
                pp.next_phase()
1457
1618
                repository = self.branch.repository
1458
 
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1619
                pb = ui.ui_factory.nested_progress_bar()
1459
1620
                basis_tree.lock_read()
1460
1621
                try:
1461
1622
                    new_basis_tree = self.branch.basis_tree()
1466
1627
                                this_tree=self,
1467
1628
                                pb=pb,
1468
1629
                                change_reporter=change_reporter)
1469
 
                    if (basis_tree.inventory.root is None and
1470
 
                        new_basis_tree.inventory.root is not None):
1471
 
                        self.set_root_id(new_basis_tree.inventory.root.file_id)
 
1630
                    basis_root_id = basis_tree.get_root_id()
 
1631
                    new_root_id = new_basis_tree.get_root_id()
 
1632
                    if basis_root_id != new_root_id:
 
1633
                        self.set_root_id(new_root_id)
1472
1634
                finally:
1473
1635
                    pb.finished()
1474
1636
                    basis_tree.unlock()
1476
1638
                # reuse the revisiontree we merged against to set the new
1477
1639
                # tree data.
1478
1640
                parent_trees = [(self.branch.last_revision(), new_basis_tree)]
1479
 
                # we have to pull the merge trees out again, because 
1480
 
                # merge_inner has set the ids. - this corner is not yet 
 
1641
                # we have to pull the merge trees out again, because
 
1642
                # merge_inner has set the ids. - this corner is not yet
1481
1643
                # layered well enough to prevent double handling.
1482
1644
                # XXX TODO: Fix the double handling: telling the tree about
1483
1645
                # the already known parent data is wasteful.
1494
1656
    @needs_write_lock
1495
1657
    def put_file_bytes_non_atomic(self, file_id, bytes):
1496
1658
        """See MutableTree.put_file_bytes_non_atomic."""
1497
 
        file_id = osutils.safe_file_id(file_id)
1498
1659
        stream = file(self.id2abspath(file_id), 'wb')
1499
1660
        try:
1500
1661
            stream.write(bytes)
1522
1683
 
1523
1684
            fl = []
1524
1685
            for subf in os.listdir(dirabs):
1525
 
                if subf == '.bzr':
 
1686
                if self.bzrdir.is_control_filename(subf):
1526
1687
                    continue
1527
1688
                if subf not in dir_entry.children:
1528
 
                    subf_norm, can_access = osutils.normalized_filename(subf)
 
1689
                    try:
 
1690
                        (subf_norm,
 
1691
                         can_access) = osutils.normalized_filename(subf)
 
1692
                    except UnicodeDecodeError:
 
1693
                        path_os_enc = path.encode(osutils._fs_enc)
 
1694
                        relpath = path_os_enc + '/' + subf
 
1695
                        raise errors.BadFilenameEncoding(relpath,
 
1696
                                                         osutils._fs_enc)
1529
1697
                    if subf_norm != subf and can_access:
1530
1698
                        if subf_norm not in dir_entry.children:
1531
1699
                            fl.append(subf_norm)
1532
1700
                    else:
1533
1701
                        fl.append(subf)
1534
 
            
 
1702
 
1535
1703
            fl.sort()
1536
1704
            for subf in fl:
1537
1705
                subp = pathjoin(path, subf)
1553
1721
        if ignoreset is not None:
1554
1722
            return ignoreset
1555
1723
 
1556
 
        ignore_globs = set(bzrlib.DEFAULT_IGNORE)
 
1724
        ignore_globs = set()
1557
1725
        ignore_globs.update(ignores.get_runtime_ignores())
1558
1726
        ignore_globs.update(ignores.get_user_ignores())
1559
1727
        if self.has_filename(bzrlib.IGNORE_FILENAME):
1574
1742
        r"""Check whether the filename matches an ignore pattern.
1575
1743
 
1576
1744
        Patterns containing '/' or '\' need to match the whole path;
1577
 
        others match against only the last component.
 
1745
        others match against only the last component.  Patterns starting
 
1746
        with '!' are ignore exceptions.  Exceptions take precedence
 
1747
        over regular patterns and cause the filename to not be ignored.
1578
1748
 
1579
1749
        If the file is ignored, returns the pattern which caused it to
1580
1750
        be ignored, otherwise None.  So this can simply be used as a
1581
1751
        boolean if desired."""
1582
1752
        if getattr(self, '_ignoreglobster', None) is None:
1583
 
            self._ignoreglobster = globbing.Globster(self.get_ignore_list())
 
1753
            self._ignoreglobster = globbing.ExceptionGlobster(self.get_ignore_list())
1584
1754
        return self._ignoreglobster.match(filename)
1585
1755
 
1586
1756
    def kind(self, file_id):
1587
1757
        return file_kind(self.id2abspath(file_id))
1588
1758
 
 
1759
    def stored_kind(self, file_id):
 
1760
        """See Tree.stored_kind"""
 
1761
        return self.inventory[file_id].kind
 
1762
 
1589
1763
    def _comparison_data(self, entry, path):
1590
1764
        abspath = self.abspath(path)
1591
1765
        try:
1622
1796
    @needs_read_lock
1623
1797
    def _last_revision(self):
1624
1798
        """helper for get_parent_ids."""
1625
 
        return self.branch.last_revision()
 
1799
        return _mod_revision.ensure_null(self.branch.last_revision())
1626
1800
 
1627
1801
    def is_locked(self):
1628
1802
        return self._control_files.is_locked()
1673
1847
    def _reset_data(self):
1674
1848
        """Reset transient data that cannot be revalidated."""
1675
1849
        self._inventory_is_modified = False
1676
 
        result = self._deserialize(self._control_files.get('inventory'))
 
1850
        f = self._transport.get('inventory')
 
1851
        try:
 
1852
            result = self._deserialize(f)
 
1853
        finally:
 
1854
            f.close()
1677
1855
        self._set_inventory(result, dirty=False)
1678
1856
 
1679
1857
    @needs_tree_write_lock
1680
1858
    def set_last_revision(self, new_revision):
1681
1859
        """Change the last revision in the working tree."""
1682
 
        new_revision = osutils.safe_revision_id(new_revision)
1683
1860
        if self._change_last_revision(new_revision):
1684
1861
            self._cache_basis_inventory(new_revision)
1685
1862
 
1686
1863
    def _change_last_revision(self, new_revision):
1687
1864
        """Template method part of set_last_revision to perform the change.
1688
 
        
 
1865
 
1689
1866
        This is used to allow WorkingTree3 instances to not affect branch
1690
1867
        when their last revision is set.
1691
1868
        """
1692
 
        if new_revision is None:
 
1869
        if _mod_revision.is_null(new_revision):
1693
1870
            self.branch.set_revision_history([])
1694
1871
            return False
1695
1872
        try:
1701
1878
 
1702
1879
    def _write_basis_inventory(self, xml):
1703
1880
        """Write the basis inventory XML to the basis-inventory file"""
1704
 
        assert isinstance(xml, str), 'serialised xml must be bytestring.'
1705
1881
        path = self._basis_inventory_name()
1706
1882
        sio = StringIO(xml)
1707
 
        self._control_files.put(path, sio)
 
1883
        self._transport.put_file(path, sio,
 
1884
            mode=self.bzrdir._get_file_mode())
1708
1885
 
1709
1886
    def _create_basis_xml_from_inventory(self, revision_id, inventory):
1710
1887
        """Create the text that will be saved in basis-inventory"""
1711
 
        # TODO: jam 20070209 This should be redundant, as the revision_id
1712
 
        #       as all callers should have already converted the revision_id to
1713
 
        #       utf8
1714
 
        inventory.revision_id = osutils.safe_revision_id(revision_id)
 
1888
        inventory.revision_id = revision_id
1715
1889
        return xml7.serializer_v7.write_inventory_to_string(inventory)
1716
1890
 
1717
1891
    def _cache_basis_inventory(self, new_revision):
1720
1894
        # as commit already has that ready-to-use [while the format is the
1721
1895
        # same, that is].
1722
1896
        try:
1723
 
            # this double handles the inventory - unpack and repack - 
 
1897
            # this double handles the inventory - unpack and repack -
1724
1898
            # but is easier to understand. We can/should put a conditional
1725
1899
            # in here based on whether the inventory is in the latest format
1726
1900
            # - perhaps we should repack all inventories on a repository
1727
1901
            # upgrade ?
1728
1902
            # the fast path is to copy the raw xml from the repository. If the
1729
 
            # xml contains 'revision_id="', then we assume the right 
 
1903
            # xml contains 'revision_id="', then we assume the right
1730
1904
            # revision_id is set. We must check for this full string, because a
1731
1905
            # root node id can legitimately look like 'revision_id' but cannot
1732
1906
            # contain a '"'.
1733
1907
            xml = self.branch.repository.get_inventory_xml(new_revision)
1734
1908
            firstline = xml.split('\n', 1)[0]
1735
 
            if (not 'revision_id="' in firstline or 
 
1909
            if (not 'revision_id="' in firstline or
1736
1910
                'format="7"' not in firstline):
1737
 
                inv = self.branch.repository.deserialise_inventory(
1738
 
                    new_revision, xml)
 
1911
                inv = self.branch.repository._serializer.read_inventory_from_string(
 
1912
                    xml, new_revision)
1739
1913
                xml = self._create_basis_xml_from_inventory(new_revision, inv)
1740
1914
            self._write_basis_inventory(xml)
1741
1915
        except (errors.NoSuchRevision, errors.RevisionNotPresent):
1744
1918
    def read_basis_inventory(self):
1745
1919
        """Read the cached basis inventory."""
1746
1920
        path = self._basis_inventory_name()
1747
 
        return self._control_files.get(path).read()
1748
 
        
 
1921
        return self._transport.get_bytes(path)
 
1922
 
1749
1923
    @needs_read_lock
1750
1924
    def read_working_inventory(self):
1751
1925
        """Read the working inventory.
1752
 
        
 
1926
 
1753
1927
        :raises errors.InventoryModified: read_working_inventory will fail
1754
1928
            when the current in memory inventory has been modified.
1755
1929
        """
1756
 
        # conceptually this should be an implementation detail of the tree. 
 
1930
        # conceptually this should be an implementation detail of the tree.
1757
1931
        # XXX: Deprecate this.
1758
1932
        # ElementTree does its own conversion from UTF-8, so open in
1759
1933
        # binary.
1760
1934
        if self._inventory_is_modified:
1761
1935
            raise errors.InventoryModified(self)
1762
 
        result = self._deserialize(self._control_files.get('inventory'))
 
1936
        f = self._transport.get('inventory')
 
1937
        try:
 
1938
            result = self._deserialize(f)
 
1939
        finally:
 
1940
            f.close()
1763
1941
        self._set_inventory(result, dirty=False)
1764
1942
        return result
1765
1943
 
1766
1944
    @needs_tree_write_lock
1767
 
    def remove(self, files, verbose=False, to_file=None):
1768
 
        """Remove nominated files from the working inventory..
1769
 
 
1770
 
        This does not remove their text.  This does not run on XXX on what? RBC
1771
 
 
1772
 
        TODO: Refuse to remove modified files unless --force is given?
1773
 
 
1774
 
        TODO: Do something useful with directories.
1775
 
 
1776
 
        TODO: Should this remove the text or not?  Tough call; not
1777
 
        removing may be useful and the user can just use use rm, and
1778
 
        is the opposite of add.  Removing it is consistent with most
1779
 
        other tools.  Maybe an option.
 
1945
    def remove(self, files, verbose=False, to_file=None, keep_files=True,
 
1946
        force=False):
 
1947
        """Remove nominated files from the working inventory.
 
1948
 
 
1949
        :files: File paths relative to the basedir.
 
1950
        :keep_files: If true, the files will also be kept.
 
1951
        :force: Delete files and directories, even if they are changed and
 
1952
            even if the directories are not empty.
1780
1953
        """
1781
 
        ## TODO: Normalize names
1782
 
        ## TODO: Remove nested loops; better scalability
1783
1954
        if isinstance(files, basestring):
1784
1955
            files = [files]
1785
1956
 
1786
 
        inv = self.inventory
1787
 
 
1788
 
        # do this before any modifications
 
1957
        inv_delta = []
 
1958
 
 
1959
        new_files=set()
 
1960
        unknown_nested_files=set()
 
1961
        if to_file is None:
 
1962
            to_file = sys.stdout
 
1963
 
 
1964
        def recurse_directory_to_add_files(directory):
 
1965
            # Recurse directory and add all files
 
1966
            # so we can check if they have changed.
 
1967
            for parent_info, file_infos in\
 
1968
                self.walkdirs(directory):
 
1969
                for relpath, basename, kind, lstat, fileid, kind in file_infos:
 
1970
                    # Is it versioned or ignored?
 
1971
                    if self.path2id(relpath) or self.is_ignored(relpath):
 
1972
                        # Add nested content for deletion.
 
1973
                        new_files.add(relpath)
 
1974
                    else:
 
1975
                        # Files which are not versioned and not ignored
 
1976
                        # should be treated as unknown.
 
1977
                        unknown_nested_files.add((relpath, None, kind))
 
1978
 
 
1979
        for filename in files:
 
1980
            # Get file name into canonical form.
 
1981
            abspath = self.abspath(filename)
 
1982
            filename = self.relpath(abspath)
 
1983
            if len(filename) > 0:
 
1984
                new_files.add(filename)
 
1985
                recurse_directory_to_add_files(filename)
 
1986
 
 
1987
        files = list(new_files)
 
1988
 
 
1989
        if len(files) == 0:
 
1990
            return # nothing to do
 
1991
 
 
1992
        # Sort needed to first handle directory content before the directory
 
1993
        files.sort(reverse=True)
 
1994
 
 
1995
        # Bail out if we are going to delete files we shouldn't
 
1996
        if not keep_files and not force:
 
1997
            has_changed_files = len(unknown_nested_files) > 0
 
1998
            if not has_changed_files:
 
1999
                for (file_id, path, content_change, versioned, parent_id, name,
 
2000
                     kind, executable) in self.iter_changes(self.basis_tree(),
 
2001
                         include_unchanged=True, require_versioned=False,
 
2002
                         want_unversioned=True, specific_files=files):
 
2003
                    if versioned == (False, False):
 
2004
                        # The record is unknown ...
 
2005
                        if not self.is_ignored(path[1]):
 
2006
                            # ... but not ignored
 
2007
                            has_changed_files = True
 
2008
                            break
 
2009
                    elif content_change and (kind[1] is not None):
 
2010
                        # Versioned and changed, but not deleted
 
2011
                        has_changed_files = True
 
2012
                        break
 
2013
 
 
2014
            if has_changed_files:
 
2015
                # Make delta show ALL applicable changes in error message.
 
2016
                tree_delta = self.changes_from(self.basis_tree(),
 
2017
                    require_versioned=False, want_unversioned=True,
 
2018
                    specific_files=files)
 
2019
                for unknown_file in unknown_nested_files:
 
2020
                    if unknown_file not in tree_delta.unversioned:
 
2021
                        tree_delta.unversioned.extend((unknown_file,))
 
2022
                raise errors.BzrRemoveChangedFilesError(tree_delta)
 
2023
 
 
2024
        # Build inv_delta and delete files where applicable,
 
2025
        # do this before any modifications to inventory.
1789
2026
        for f in files:
1790
 
            fid = inv.path2id(f)
 
2027
            fid = self.path2id(f)
 
2028
            message = None
1791
2029
            if not fid:
1792
 
                note("%s is not versioned."%f)
 
2030
                message = "%s is not versioned." % (f,)
1793
2031
            else:
1794
2032
                if verbose:
1795
 
                    # having remove it, it must be either ignored or unknown
 
2033
                    # having removed it, it must be either ignored or unknown
1796
2034
                    if self.is_ignored(f):
1797
2035
                        new_status = 'I'
1798
2036
                    else:
1799
2037
                        new_status = '?'
1800
 
                    textui.show_status(new_status, inv[fid].kind, f,
1801
 
                                       to_file=to_file)
1802
 
                del inv[fid]
1803
 
 
1804
 
        self._write_inventory(inv)
 
2038
                    # XXX: Really should be a more abstract reporter interface
 
2039
                    kind_ch = osutils.kind_marker(self.kind(fid))
 
2040
                    to_file.write(new_status + '       ' + f + kind_ch + '\n')
 
2041
                # Unversion file
 
2042
                inv_delta.append((f, None, fid, None))
 
2043
                message = "removed %s" % (f,)
 
2044
 
 
2045
            if not keep_files:
 
2046
                abs_path = self.abspath(f)
 
2047
                if osutils.lexists(abs_path):
 
2048
                    if (osutils.isdir(abs_path) and
 
2049
                        len(os.listdir(abs_path)) > 0):
 
2050
                        if force:
 
2051
                            osutils.rmtree(abs_path)
 
2052
                        else:
 
2053
                            message = "%s is not an empty directory "\
 
2054
                                "and won't be deleted." % (f,)
 
2055
                    else:
 
2056
                        osutils.delete_any(abs_path)
 
2057
                        message = "deleted %s" % (f,)
 
2058
                elif message is not None:
 
2059
                    # Only care if we haven't done anything yet.
 
2060
                    message = "%s does not exist." % (f,)
 
2061
 
 
2062
            # Print only one message (if any) per file.
 
2063
            if message is not None:
 
2064
                note(message)
 
2065
        self.apply_inventory_delta(inv_delta)
1805
2066
 
1806
2067
    @needs_tree_write_lock
1807
 
    def revert(self, filenames, old_tree=None, backups=True, 
 
2068
    def revert(self, filenames=None, old_tree=None, backups=True,
1808
2069
               pb=DummyProgress(), report_changes=False):
1809
2070
        from bzrlib.conflicts import resolve
 
2071
        if filenames == []:
 
2072
            filenames = None
 
2073
            symbol_versioning.warn('Using [] to revert all files is deprecated'
 
2074
                ' as of bzr 0.91.  Please use None (the default) instead.',
 
2075
                DeprecationWarning, stacklevel=2)
1810
2076
        if old_tree is None:
1811
 
            old_tree = self.basis_tree()
1812
 
        conflicts = transform.revert(self, old_tree, filenames, backups, pb,
1813
 
                                     report_changes)
1814
 
        if not len(filenames):
1815
 
            self.set_parent_ids(self.get_parent_ids()[:1])
1816
 
            resolve(self)
 
2077
            basis_tree = self.basis_tree()
 
2078
            basis_tree.lock_read()
 
2079
            old_tree = basis_tree
1817
2080
        else:
1818
 
            resolve(self, filenames, ignore_misses=True)
 
2081
            basis_tree = None
 
2082
        try:
 
2083
            conflicts = transform.revert(self, old_tree, filenames, backups, pb,
 
2084
                                         report_changes)
 
2085
            if filenames is None and len(self.get_parent_ids()) > 1:
 
2086
                parent_trees = []
 
2087
                last_revision = self.last_revision()
 
2088
                if last_revision != _mod_revision.NULL_REVISION:
 
2089
                    if basis_tree is None:
 
2090
                        basis_tree = self.basis_tree()
 
2091
                        basis_tree.lock_read()
 
2092
                    parent_trees.append((last_revision, basis_tree))
 
2093
                self.set_parent_trees(parent_trees)
 
2094
                resolve(self)
 
2095
            else:
 
2096
                resolve(self, filenames, ignore_misses=True, recursive=True)
 
2097
        finally:
 
2098
            if basis_tree is not None:
 
2099
                basis_tree.unlock()
1819
2100
        return conflicts
1820
2101
 
1821
2102
    def revision_tree(self, revision_id):
1848
2129
    def set_inventory(self, new_inventory_list):
1849
2130
        from bzrlib.inventory import (Inventory,
1850
2131
                                      InventoryDirectory,
1851
 
                                      InventoryEntry,
1852
2132
                                      InventoryFile,
1853
2133
                                      InventoryLink)
1854
2134
        inv = Inventory(self.get_root_id())
1856
2136
            name = os.path.basename(path)
1857
2137
            if name == "":
1858
2138
                continue
1859
 
            # fixme, there should be a factory function inv,add_?? 
 
2139
            # fixme, there should be a factory function inv,add_??
1860
2140
            if kind == 'directory':
1861
2141
                inv.add(InventoryDirectory(file_id, name, parent))
1862
2142
            elif kind == 'file':
1870
2150
    @needs_tree_write_lock
1871
2151
    def set_root_id(self, file_id):
1872
2152
        """Set the root id for this tree."""
1873
 
        # for compatability 
 
2153
        # for compatability
1874
2154
        if file_id is None:
1875
 
            symbol_versioning.warn(symbol_versioning.zero_twelve
1876
 
                % 'WorkingTree.set_root_id with fileid=None',
1877
 
                DeprecationWarning,
1878
 
                stacklevel=3)
1879
 
            file_id = ROOT_ID
1880
 
        else:
1881
 
            file_id = osutils.safe_file_id(file_id)
 
2155
            raise ValueError(
 
2156
                'WorkingTree.set_root_id with fileid=None')
 
2157
        file_id = osutils.safe_file_id(file_id)
1882
2158
        self._set_root_id(file_id)
1883
2159
 
1884
2160
    def _set_root_id(self, file_id):
1885
2161
        """Set the root id for this tree, in a format specific manner.
1886
2162
 
1887
 
        :param file_id: The file id to assign to the root. It must not be 
 
2163
        :param file_id: The file id to assign to the root. It must not be
1888
2164
            present in the current inventory or an error will occur. It must
1889
2165
            not be None, but rather a valid file id.
1890
2166
        """
1909
2185
 
1910
2186
    def unlock(self):
1911
2187
        """See Branch.unlock.
1912
 
        
 
2188
 
1913
2189
        WorkingTree locking just uses the Branch locking facilities.
1914
2190
        This is current because all working trees have an embedded branch
1915
2191
        within them. IF in the future, we were to make branch data shareable
1916
 
        between multiple working trees, i.e. via shared storage, then we 
 
2192
        between multiple working trees, i.e. via shared storage, then we
1917
2193
        would probably want to lock both the local tree, and the branch.
1918
2194
        """
1919
2195
        raise NotImplementedError(self.unlock)
1920
2196
 
1921
 
    def update(self):
 
2197
    _marker = object()
 
2198
 
 
2199
    def update(self, change_reporter=None, possible_transports=None,
 
2200
               revision=None, old_tip=_marker):
1922
2201
        """Update a working tree along its branch.
1923
2202
 
1924
2203
        This will update the branch if its bound too, which means we have
1942
2221
        - Merge current state -> basis tree of the master w.r.t. the old tree
1943
2222
          basis.
1944
2223
        - Do a 'normal' merge of the old branch basis if it is relevant.
 
2224
 
 
2225
        :param revision: The target revision to update to. Must be in the
 
2226
            revision history.
 
2227
        :param old_tip: If branch.update() has already been run, the value it
 
2228
            returned (old tip of the branch or None). _marker is used
 
2229
            otherwise.
1945
2230
        """
1946
 
        if self.branch.get_master_branch() is not None:
 
2231
        if self.branch.get_bound_location() is not None:
1947
2232
            self.lock_write()
1948
 
            update_branch = True
 
2233
            update_branch = (old_tip is self._marker)
1949
2234
        else:
1950
2235
            self.lock_tree_write()
1951
2236
            update_branch = False
1952
2237
        try:
1953
2238
            if update_branch:
1954
 
                old_tip = self.branch.update()
 
2239
                old_tip = self.branch.update(possible_transports)
1955
2240
            else:
1956
 
                old_tip = None
1957
 
            return self._update_tree(old_tip)
 
2241
                if old_tip is self._marker:
 
2242
                    old_tip = None
 
2243
            return self._update_tree(old_tip, change_reporter, revision)
1958
2244
        finally:
1959
2245
            self.unlock()
1960
2246
 
1961
2247
    @needs_tree_write_lock
1962
 
    def _update_tree(self, old_tip=None):
 
2248
    def _update_tree(self, old_tip=None, change_reporter=None, revision=None):
1963
2249
        """Update a tree to the master branch.
1964
2250
 
1965
2251
        :param old_tip: if supplied, the previous tip revision the branch,
1971
2257
        # cant set that until we update the working trees last revision to be
1972
2258
        # one from the new branch, because it will just get absorbed by the
1973
2259
        # parent de-duplication logic.
1974
 
        # 
 
2260
        #
1975
2261
        # We MUST save it even if an error occurs, because otherwise the users
1976
2262
        # local work is unreferenced and will appear to have been lost.
1977
 
        # 
 
2263
        #
1978
2264
        result = 0
1979
2265
        try:
1980
2266
            last_rev = self.get_parent_ids()[0]
1981
2267
        except IndexError:
1982
 
            last_rev = None
1983
 
        if last_rev != self.branch.last_revision():
1984
 
            # merge tree state up to new branch tip.
 
2268
            last_rev = _mod_revision.NULL_REVISION
 
2269
        if revision is None:
 
2270
            revision = self.branch.last_revision()
 
2271
        else:
 
2272
            if revision not in self.branch.revision_history():
 
2273
                raise errors.NoSuchRevision(self.branch, revision)
 
2274
        if last_rev != _mod_revision.ensure_null(revision):
 
2275
            # merge tree state up to specified revision.
1985
2276
            basis = self.basis_tree()
1986
2277
            basis.lock_read()
1987
2278
            try:
1988
 
                to_tree = self.branch.basis_tree()
1989
 
                if basis.inventory.root is None:
1990
 
                    self.set_root_id(to_tree.inventory.root.file_id)
 
2279
                to_tree = self.branch.repository.revision_tree(revision)
 
2280
                to_root_id = to_tree.get_root_id()
 
2281
                if (basis.inventory.root is None
 
2282
                    or basis.inventory.root.file_id != to_root_id):
 
2283
                    self.set_root_id(to_root_id)
1991
2284
                    self.flush()
1992
2285
                result += merge.merge_inner(
1993
2286
                                      self.branch,
1994
2287
                                      to_tree,
1995
2288
                                      basis,
1996
 
                                      this_tree=self)
 
2289
                                      this_tree=self,
 
2290
                                      change_reporter=change_reporter)
 
2291
                self.set_last_revision(revision)
1997
2292
            finally:
1998
2293
                basis.unlock()
1999
2294
            # TODO - dedup parents list with things merged by pull ?
2000
2295
            # reuse the tree we've updated to to set the basis:
2001
 
            parent_trees = [(self.branch.last_revision(), to_tree)]
 
2296
            parent_trees = [(revision, to_tree)]
2002
2297
            merges = self.get_parent_ids()[1:]
2003
2298
            # Ideally we ask the tree for the trees here, that way the working
2004
 
            # tree can decide whether to give us teh entire tree or give us a
 
2299
            # tree can decide whether to give us the entire tree or give us a
2005
2300
            # lazy initialised tree. dirstate for instance will have the trees
2006
2301
            # in ram already, whereas a last-revision + basis-inventory tree
2007
2302
            # will not, but also does not need them when setting parents.
2008
2303
            for parent in merges:
2009
2304
                parent_trees.append(
2010
2305
                    (parent, self.branch.repository.revision_tree(parent)))
2011
 
            if old_tip is not None:
 
2306
            if (old_tip is not None and not _mod_revision.is_null(old_tip)):
2012
2307
                parent_trees.append(
2013
2308
                    (old_tip, self.branch.repository.revision_tree(old_tip)))
2014
2309
            self.set_parent_trees(parent_trees)
2017
2312
            # the working tree had the same last-revision as the master
2018
2313
            # branch did. We may still have pivot local work from the local
2019
2314
            # branch into old_tip:
2020
 
            if old_tip is not None:
 
2315
            if (old_tip is not None and not _mod_revision.is_null(old_tip)):
2021
2316
                self.add_parent_tree_id(old_tip)
2022
 
        if old_tip and old_tip != last_rev:
 
2317
        if (old_tip is not None and not _mod_revision.is_null(old_tip)
 
2318
            and old_tip != last_rev):
2023
2319
            # our last revision was not the prior branch last revision
2024
2320
            # and we have converted that last revision to a pending merge.
2025
2321
            # base is somewhere between the branch tip now
2032
2328
            #       inventory and calls tree._write_inventory(). Ultimately we
2033
2329
            #       should be able to remove this extra flush.
2034
2330
            self.flush()
2035
 
            from bzrlib.revision import common_ancestor
2036
 
            try:
2037
 
                base_rev_id = common_ancestor(self.branch.last_revision(),
2038
 
                                              old_tip,
2039
 
                                              self.branch.repository)
2040
 
            except errors.NoCommonAncestor:
2041
 
                base_rev_id = None
 
2331
            graph = self.branch.repository.get_graph()
 
2332
            base_rev_id = graph.find_unique_lca(revision, old_tip)
2042
2333
            base_tree = self.branch.repository.revision_tree(base_rev_id)
2043
2334
            other_tree = self.branch.repository.revision_tree(old_tip)
2044
2335
            result += merge.merge_inner(
2045
2336
                                  self.branch,
2046
2337
                                  other_tree,
2047
2338
                                  base_tree,
2048
 
                                  this_tree=self)
 
2339
                                  this_tree=self,
 
2340
                                  change_reporter=change_reporter)
2049
2341
        return result
2050
2342
 
2051
2343
    def _write_hashcache_if_dirty(self):
2103
2395
    def walkdirs(self, prefix=""):
2104
2396
        """Walk the directories of this tree.
2105
2397
 
 
2398
        returns a generator which yields items in the form:
 
2399
                ((curren_directory_path, fileid),
 
2400
                 [(file1_path, file1_name, file1_kind, (lstat), file1_id,
 
2401
                   file1_kind), ... ])
 
2402
 
2106
2403
        This API returns a generator, which is only valid during the current
2107
2404
        tree transaction - within a single lock_read or lock_write duration.
2108
2405
 
2109
 
        If the tree is not locked, it may cause an error to be raised, depending
2110
 
        on the tree implementation.
 
2406
        If the tree is not locked, it may cause an error to be raised,
 
2407
        depending on the tree implementation.
2111
2408
        """
2112
2409
        disk_top = self.abspath(prefix)
2113
2410
        if disk_top.endswith('/'):
2119
2416
            current_disk = disk_iterator.next()
2120
2417
            disk_finished = False
2121
2418
        except OSError, e:
2122
 
            if e.errno != errno.ENOENT:
 
2419
            if not (e.errno == errno.ENOENT or
 
2420
                (sys.platform == 'win32' and e.errno == ERROR_PATH_NOT_FOUND)):
2123
2421
                raise
2124
2422
            current_disk = None
2125
2423
            disk_finished = True
2130
2428
            current_inv = None
2131
2429
            inv_finished = True
2132
2430
        while not inv_finished or not disk_finished:
 
2431
            if current_disk:
 
2432
                ((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
 
2433
                    cur_disk_dir_content) = current_disk
 
2434
            else:
 
2435
                ((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
 
2436
                    cur_disk_dir_content) = ((None, None), None)
2133
2437
            if not disk_finished:
2134
2438
                # strip out .bzr dirs
2135
 
                if current_disk[0][1][top_strip_len:] == '':
2136
 
                    # osutils.walkdirs can be made nicer - 
 
2439
                if (cur_disk_dir_path_from_top[top_strip_len:] == '' and
 
2440
                    len(cur_disk_dir_content) > 0):
 
2441
                    # osutils.walkdirs can be made nicer -
2137
2442
                    # yield the path-from-prefix rather than the pathjoined
2138
2443
                    # value.
2139
 
                    bzrdir_loc = bisect_left(current_disk[1], ('.bzr', '.bzr'))
2140
 
                    if current_disk[1][bzrdir_loc][0] == '.bzr':
 
2444
                    bzrdir_loc = bisect_left(cur_disk_dir_content,
 
2445
                        ('.bzr', '.bzr'))
 
2446
                    if (bzrdir_loc < len(cur_disk_dir_content)
 
2447
                        and self.bzrdir.is_control_filename(
 
2448
                            cur_disk_dir_content[bzrdir_loc][0])):
2141
2449
                        # we dont yield the contents of, or, .bzr itself.
2142
 
                        del current_disk[1][bzrdir_loc]
 
2450
                        del cur_disk_dir_content[bzrdir_loc]
2143
2451
            if inv_finished:
2144
2452
                # everything is unknown
2145
2453
                direction = 1
2147
2455
                # everything is missing
2148
2456
                direction = -1
2149
2457
            else:
2150
 
                direction = cmp(current_inv[0][0], current_disk[0][0])
 
2458
                direction = cmp(current_inv[0][0], cur_disk_dir_relpath)
2151
2459
            if direction > 0:
2152
2460
                # disk is before inventory - unknown
2153
2461
                dirblock = [(relpath, basename, kind, stat, None, None) for
2154
 
                    relpath, basename, kind, stat, top_path in current_disk[1]]
2155
 
                yield (current_disk[0][0], None), dirblock
 
2462
                    relpath, basename, kind, stat, top_path in
 
2463
                    cur_disk_dir_content]
 
2464
                yield (cur_disk_dir_relpath, None), dirblock
2156
2465
                try:
2157
2466
                    current_disk = disk_iterator.next()
2158
2467
                except StopIteration:
2160
2469
            elif direction < 0:
2161
2470
                # inventory is before disk - missing.
2162
2471
                dirblock = [(relpath, basename, 'unknown', None, fileid, kind)
2163
 
                    for relpath, basename, dkind, stat, fileid, kind in 
 
2472
                    for relpath, basename, dkind, stat, fileid, kind in
2164
2473
                    current_inv[1]]
2165
2474
                yield (current_inv[0][0], current_inv[0][1]), dirblock
2166
2475
                try:
2172
2481
                # merge the inventory and disk data together
2173
2482
                dirblock = []
2174
2483
                for relpath, subiterator in itertools.groupby(sorted(
2175
 
                    current_inv[1] + current_disk[1], key=operator.itemgetter(0)), operator.itemgetter(1)):
 
2484
                    current_inv[1] + cur_disk_dir_content,
 
2485
                    key=operator.itemgetter(0)), operator.itemgetter(1)):
2176
2486
                    path_elements = list(subiterator)
2177
2487
                    if len(path_elements) == 2:
2178
2488
                        inv_row, disk_row = path_elements
2204
2514
                    disk_finished = True
2205
2515
 
2206
2516
    def _walkdirs(self, prefix=""):
 
2517
        """Walk the directories of this tree.
 
2518
 
 
2519
           :prefix: is used as the directrory to start with.
 
2520
           returns a generator which yields items in the form:
 
2521
                ((curren_directory_path, fileid),
 
2522
                 [(file1_path, file1_name, file1_kind, None, file1_id,
 
2523
                   file1_kind), ... ])
 
2524
        """
2207
2525
        _directory = 'directory'
2208
2526
        # get the root in the inventory
2209
2527
        inv = self.inventory
2223
2541
                relroot = ""
2224
2542
            # FIXME: stash the node in pending
2225
2543
            entry = inv[top_id]
2226
 
            for name, child in entry.sorted_children():
2227
 
                dirblock.append((relroot + name, name, child.kind, None,
2228
 
                    child.file_id, child.kind
2229
 
                    ))
 
2544
            if entry.kind == 'directory':
 
2545
                for name, child in entry.sorted_children():
 
2546
                    dirblock.append((relroot + name, name, child.kind, None,
 
2547
                        child.file_id, child.kind
 
2548
                        ))
2230
2549
            yield (currentdir[0], entry.file_id), dirblock
2231
2550
            # push the user specified dirs from dirblock
2232
2551
            for dir in reversed(dirblock):
2265
2584
        self.set_conflicts(un_resolved)
2266
2585
        return un_resolved, resolved
2267
2586
 
 
2587
    @needs_read_lock
 
2588
    def _check(self, references):
 
2589
        """Check the tree for consistency.
 
2590
 
 
2591
        :param references: A dict with keys matching the items returned by
 
2592
            self._get_check_refs(), and values from looking those keys up in
 
2593
            the repository.
 
2594
        """
 
2595
        tree_basis = self.basis_tree()
 
2596
        tree_basis.lock_read()
 
2597
        try:
 
2598
            repo_basis = references[('trees', self.last_revision())]
 
2599
            if len(list(repo_basis.iter_changes(tree_basis))) > 0:
 
2600
                raise errors.BzrCheckError(
 
2601
                    "Mismatched basis inventory content.")
 
2602
            self._validate()
 
2603
        finally:
 
2604
            tree_basis.unlock()
 
2605
 
2268
2606
    def _validate(self):
2269
2607
        """Validate internal structures.
2270
2608
 
2276
2614
        """
2277
2615
        return
2278
2616
 
 
2617
    def _get_rules_searcher(self, default_searcher):
 
2618
        """See Tree._get_rules_searcher."""
 
2619
        if self._rules_searcher is None:
 
2620
            self._rules_searcher = super(WorkingTree,
 
2621
                self)._get_rules_searcher(default_searcher)
 
2622
        return self._rules_searcher
 
2623
 
 
2624
    def get_shelf_manager(self):
 
2625
        """Return the ShelfManager for this WorkingTree."""
 
2626
        from bzrlib.shelf import ShelfManager
 
2627
        return ShelfManager(self, self._transport)
 
2628
 
2279
2629
 
2280
2630
class WorkingTree2(WorkingTree):
2281
2631
    """This is the Format 2 working tree.
2282
2632
 
2283
 
    This was the first weave based working tree. 
 
2633
    This was the first weave based working tree.
2284
2634
     - uses os locks for locking.
2285
2635
     - uses the branch last-revision.
2286
2636
    """
2296
2646
        if self._inventory is None:
2297
2647
            self.read_working_inventory()
2298
2648
 
 
2649
    def _get_check_refs(self):
 
2650
        """Return the references needed to perform a check of this tree."""
 
2651
        return [('trees', self.last_revision())]
 
2652
 
2299
2653
    def lock_tree_write(self):
2300
2654
        """See WorkingTree.lock_tree_write().
2301
2655
 
2310
2664
            raise
2311
2665
 
2312
2666
    def unlock(self):
 
2667
        # do non-implementation specific cleanup
 
2668
        self._cleanup()
 
2669
 
2313
2670
        # we share control files:
2314
2671
        if self._control_files._lock_count == 3:
2315
2672
            # _inventory_is_modified is always False during a read lock.
2316
2673
            if self._inventory_is_modified:
2317
2674
                self.flush()
2318
2675
            self._write_hashcache_if_dirty()
2319
 
                    
 
2676
 
2320
2677
        # reverse order of locking.
2321
2678
        try:
2322
2679
            return self._control_files.unlock()
2338
2695
    def _last_revision(self):
2339
2696
        """See Mutable.last_revision."""
2340
2697
        try:
2341
 
            return osutils.safe_revision_id(
2342
 
                        self._control_files.get('last-revision').read())
 
2698
            return self._transport.get_bytes('last-revision')
2343
2699
        except errors.NoSuchFile:
2344
 
            return None
 
2700
            return _mod_revision.NULL_REVISION
2345
2701
 
2346
2702
    def _change_last_revision(self, revision_id):
2347
2703
        """See WorkingTree._change_last_revision."""
2348
 
        if revision_id is None or revision_id == NULL_REVISION:
 
2704
        if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
2349
2705
            try:
2350
 
                self._control_files._transport.delete('last-revision')
 
2706
                self._transport.delete('last-revision')
2351
2707
            except errors.NoSuchFile:
2352
2708
                pass
2353
2709
            return False
2354
2710
        else:
2355
 
            self._control_files.put_bytes('last-revision', revision_id)
 
2711
            self._transport.put_bytes('last-revision', revision_id,
 
2712
                mode=self.bzrdir._get_file_mode())
2356
2713
            return True
2357
2714
 
 
2715
    def _get_check_refs(self):
 
2716
        """Return the references needed to perform a check of this tree."""
 
2717
        return [('trees', self.last_revision())]
 
2718
 
2358
2719
    @needs_tree_write_lock
2359
2720
    def set_conflicts(self, conflicts):
2360
 
        self._put_rio('conflicts', conflicts.to_stanzas(), 
 
2721
        self._put_rio('conflicts', conflicts.to_stanzas(),
2361
2722
                      CONFLICT_HEADER_1)
2362
2723
 
2363
2724
    @needs_tree_write_lock
2370
2731
    @needs_read_lock
2371
2732
    def conflicts(self):
2372
2733
        try:
2373
 
            confile = self._control_files.get('conflicts')
 
2734
            confile = self._transport.get('conflicts')
2374
2735
        except errors.NoSuchFile:
2375
2736
            return _mod_conflicts.ConflictList()
2376
2737
        try:
2377
 
            if confile.next() != CONFLICT_HEADER_1 + '\n':
 
2738
            try:
 
2739
                if confile.next() != CONFLICT_HEADER_1 + '\n':
 
2740
                    raise errors.ConflictFormatError()
 
2741
            except StopIteration:
2378
2742
                raise errors.ConflictFormatError()
2379
 
        except StopIteration:
2380
 
            raise errors.ConflictFormatError()
2381
 
        return _mod_conflicts.ConflictList.from_stanzas(RioReader(confile))
 
2743
            return _mod_conflicts.ConflictList.from_stanzas(RioReader(confile))
 
2744
        finally:
 
2745
            confile.close()
2382
2746
 
2383
2747
    def unlock(self):
 
2748
        # do non-implementation specific cleanup
 
2749
        self._cleanup()
2384
2750
        if self._control_files._lock_count == 1:
2385
2751
            # _inventory_is_modified is always False during a read lock.
2386
2752
            if self._inventory_is_modified:
2399
2765
            return path[:-len(suffix)]
2400
2766
 
2401
2767
 
2402
 
@deprecated_function(zero_eight)
2403
 
def is_control_file(filename):
2404
 
    """See WorkingTree.is_control_filename(filename)."""
2405
 
    ## FIXME: better check
2406
 
    filename = normpath(filename)
2407
 
    while filename != '':
2408
 
        head, tail = os.path.split(filename)
2409
 
        ## mutter('check %r for control file' % ((head, tail),))
2410
 
        if tail == '.bzr':
2411
 
            return True
2412
 
        if filename == head:
2413
 
            break
2414
 
        filename = head
2415
 
    return False
2416
 
 
2417
 
 
2418
2768
class WorkingTreeFormat(object):
2419
2769
    """An encapsulation of the initialization and open routines for a format.
2420
2770
 
2423
2773
     * a format string,
2424
2774
     * an open routine.
2425
2775
 
2426
 
    Formats are placed in an dict by their format string for reference 
 
2776
    Formats are placed in an dict by their format string for reference
2427
2777
    during workingtree opening. Its not required that these be instances, they
2428
 
    can be classes themselves with class methods - it simply depends on 
 
2778
    can be classes themselves with class methods - it simply depends on
2429
2779
    whether state is needed for a given format or not.
2430
2780
 
2431
2781
    Once a format is deprecated, just deprecate the initialize and open
2432
 
    methods on the format class. Do not deprecate the object, as the 
 
2782
    methods on the format class. Do not deprecate the object, as the
2433
2783
    object will be created every time regardless.
2434
2784
    """
2435
2785
 
2448
2798
        """Return the format for the working tree object in a_bzrdir."""
2449
2799
        try:
2450
2800
            transport = a_bzrdir.get_workingtree_transport(None)
2451
 
            format_string = transport.get("format").read()
 
2801
            format_string = transport.get_bytes("format")
2452
2802
            return klass._formats[format_string]
2453
2803
        except errors.NoSuchFile:
2454
2804
            raise errors.NoWorkingTree(base=transport.base)
2455
2805
        except KeyError:
2456
 
            raise errors.UnknownFormatError(format=format_string)
 
2806
            raise errors.UnknownFormatError(format=format_string,
 
2807
                                            kind="working tree")
2457
2808
 
2458
2809
    def __eq__(self, other):
2459
2810
        return self.__class__ is other.__class__
2478
2829
        """Is this format supported?
2479
2830
 
2480
2831
        Supported formats can be initialized and opened.
2481
 
        Unsupported formats may not support initialization or committing or 
 
2832
        Unsupported formats may not support initialization or committing or
2482
2833
        some other features depending on the reason for not being supported.
2483
2834
        """
2484
2835
        return True
2485
2836
 
 
2837
    def supports_content_filtering(self):
 
2838
        """True if this format supports content filtering."""
 
2839
        return False
 
2840
 
 
2841
    def supports_views(self):
 
2842
        """True if this format supports stored views."""
 
2843
        return False
 
2844
 
2486
2845
    @classmethod
2487
2846
    def register_format(klass, format):
2488
2847
        klass._formats[format.get_format_string()] = format
2493
2852
 
2494
2853
    @classmethod
2495
2854
    def unregister_format(klass, format):
2496
 
        assert klass._formats[format.get_format_string()] is format
2497
2855
        del klass._formats[format.get_format_string()]
2498
2856
 
2499
2857
 
2500
2858
class WorkingTreeFormat2(WorkingTreeFormat):
2501
 
    """The second working tree format. 
 
2859
    """The second working tree format.
2502
2860
 
2503
2861
    This format modified the hash cache from the format 1 hash cache.
2504
2862
    """
2509
2867
        """See WorkingTreeFormat.get_format_description()."""
2510
2868
        return "Working tree format 2"
2511
2869
 
2512
 
    def stub_initialize_remote(self, control_files):
2513
 
        """As a special workaround create critical control files for a remote working tree
2514
 
        
 
2870
    def _stub_initialize_on_transport(self, transport, file_mode):
 
2871
        """Workaround: create control files for a remote working tree.
 
2872
 
2515
2873
        This ensures that it can later be updated and dealt with locally,
2516
 
        since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with 
 
2874
        since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with
2517
2875
        no working tree.  (See bug #43064).
2518
2876
        """
2519
2877
        sio = StringIO()
2520
 
        inv = Inventory()
2521
 
        xml5.serializer_v5.write_inventory(inv, sio)
 
2878
        inv = inventory.Inventory()
 
2879
        xml5.serializer_v5.write_inventory(inv, sio, working=True)
2522
2880
        sio.seek(0)
2523
 
        control_files.put('inventory', sio)
2524
 
 
2525
 
        control_files.put_bytes('pending-merges', '')
2526
 
        
2527
 
 
2528
 
    def initialize(self, a_bzrdir, revision_id=None):
 
2881
        transport.put_file('inventory', sio, file_mode)
 
2882
        transport.put_bytes('pending-merges', '', file_mode)
 
2883
 
 
2884
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
 
2885
                   accelerator_tree=None, hardlink=False):
2529
2886
        """See WorkingTreeFormat.initialize()."""
2530
2887
        if not isinstance(a_bzrdir.transport, LocalTransport):
2531
2888
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
2532
 
        branch = a_bzrdir.open_branch()
2533
 
        if revision_id is not None:
2534
 
            revision_id = osutils.safe_revision_id(revision_id)
2535
 
            branch.lock_write()
2536
 
            try:
2537
 
                revision_history = branch.revision_history()
2538
 
                try:
2539
 
                    position = revision_history.index(revision_id)
2540
 
                except ValueError:
2541
 
                    raise errors.NoSuchRevision(branch, revision_id)
2542
 
                branch.set_revision_history(revision_history[:position + 1])
2543
 
            finally:
2544
 
                branch.unlock()
2545
 
        revision = branch.last_revision()
2546
 
        inv = Inventory()
 
2889
        if from_branch is not None:
 
2890
            branch = from_branch
 
2891
        else:
 
2892
            branch = a_bzrdir.open_branch()
 
2893
        if revision_id is None:
 
2894
            revision_id = _mod_revision.ensure_null(branch.last_revision())
 
2895
        branch.lock_write()
 
2896
        try:
 
2897
            branch.generate_revision_history(revision_id)
 
2898
        finally:
 
2899
            branch.unlock()
 
2900
        inv = inventory.Inventory()
2547
2901
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
2548
2902
                         branch,
2549
2903
                         inv,
2550
2904
                         _internal=True,
2551
2905
                         _format=self,
2552
2906
                         _bzrdir=a_bzrdir)
2553
 
        basis_tree = branch.repository.revision_tree(revision)
 
2907
        basis_tree = branch.repository.revision_tree(revision_id)
2554
2908
        if basis_tree.inventory.root is not None:
2555
 
            wt.set_root_id(basis_tree.inventory.root.file_id)
 
2909
            wt.set_root_id(basis_tree.get_root_id())
2556
2910
        # set the parent list and cache the basis tree.
2557
 
        wt.set_parent_trees([(revision, basis_tree)])
 
2911
        if _mod_revision.is_null(revision_id):
 
2912
            parent_trees = []
 
2913
        else:
 
2914
            parent_trees = [(revision_id, basis_tree)]
 
2915
        wt.set_parent_trees(parent_trees)
2558
2916
        transform.build_tree(basis_tree, wt)
2559
2917
        return wt
2560
2918
 
2590
2948
        - is new in bzr 0.8
2591
2949
        - uses a LockDir to guard access for writes.
2592
2950
    """
2593
 
    
 
2951
 
2594
2952
    upgrade_recommended = True
2595
2953
 
2596
2954
    def get_format_string(self):
2613
2971
 
2614
2972
    def _open_control_files(self, a_bzrdir):
2615
2973
        transport = a_bzrdir.get_workingtree_transport(None)
2616
 
        return LockableFiles(transport, self._lock_file_name, 
 
2974
        return LockableFiles(transport, self._lock_file_name,
2617
2975
                             self._lock_class)
2618
2976
 
2619
 
    def initialize(self, a_bzrdir, revision_id=None):
 
2977
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
 
2978
                   accelerator_tree=None, hardlink=False):
2620
2979
        """See WorkingTreeFormat.initialize().
2621
 
        
2622
 
        revision_id allows creating a working tree at a different
2623
 
        revision than the branch is at.
 
2980
 
 
2981
        :param revision_id: if supplied, create a working tree at a different
 
2982
            revision than the branch is at.
 
2983
        :param accelerator_tree: A tree which can be used for retrieving file
 
2984
            contents more quickly than the revision tree, i.e. a workingtree.
 
2985
            The revision tree will be used for cases where accelerator_tree's
 
2986
            content is different.
 
2987
        :param hardlink: If true, hard-link files from accelerator_tree,
 
2988
            where possible.
2624
2989
        """
2625
2990
        if not isinstance(a_bzrdir.transport, LocalTransport):
2626
2991
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
2628
2993
        control_files = self._open_control_files(a_bzrdir)
2629
2994
        control_files.create_lock()
2630
2995
        control_files.lock_write()
2631
 
        control_files.put_utf8('format', self.get_format_string())
2632
 
        branch = a_bzrdir.open_branch()
 
2996
        transport.put_bytes('format', self.get_format_string(),
 
2997
            mode=a_bzrdir._get_file_mode())
 
2998
        if from_branch is not None:
 
2999
            branch = from_branch
 
3000
        else:
 
3001
            branch = a_bzrdir.open_branch()
2633
3002
        if revision_id is None:
2634
 
            revision_id = branch.last_revision()
2635
 
        else:
2636
 
            revision_id = osutils.safe_revision_id(revision_id)
 
3003
            revision_id = _mod_revision.ensure_null(branch.last_revision())
2637
3004
        # WorkingTree3 can handle an inventory which has a unique root id.
2638
3005
        # as of bzr 0.12. However, bzr 0.11 and earlier fail to handle
2639
3006
        # those trees. And because there isn't a format bump inbetween, we
2652
3019
            basis_tree = branch.repository.revision_tree(revision_id)
2653
3020
            # only set an explicit root id if there is one to set.
2654
3021
            if basis_tree.inventory.root is not None:
2655
 
                wt.set_root_id(basis_tree.inventory.root.file_id)
2656
 
            if revision_id == NULL_REVISION:
 
3022
                wt.set_root_id(basis_tree.get_root_id())
 
3023
            if revision_id == _mod_revision.NULL_REVISION:
2657
3024
                wt.set_parent_trees([])
2658
3025
            else:
2659
3026
                wt.set_parent_trees([(revision_id, basis_tree)])
2666
3033
        return wt
2667
3034
 
2668
3035
    def _initial_inventory(self):
2669
 
        return Inventory()
 
3036
        return inventory.Inventory()
2670
3037
 
2671
3038
    def __init__(self):
2672
3039
        super(WorkingTreeFormat3, self).__init__()
2687
3054
 
2688
3055
    def _open(self, a_bzrdir, control_files):
2689
3056
        """Open the tree itself.
2690
 
        
 
3057
 
2691
3058
        :param a_bzrdir: the dir for the tree.
2692
3059
        :param control_files: the control files for the tree.
2693
3060
        """
2701
3068
        return self.get_format_string()
2702
3069
 
2703
3070
 
2704
 
__default_format = WorkingTreeFormat4()
 
3071
__default_format = WorkingTreeFormat6()
2705
3072
WorkingTreeFormat.register_format(__default_format)
 
3073
WorkingTreeFormat.register_format(WorkingTreeFormat5())
 
3074
WorkingTreeFormat.register_format(WorkingTreeFormat4())
2706
3075
WorkingTreeFormat.register_format(WorkingTreeFormat3())
2707
3076
WorkingTreeFormat.set_default_format(__default_format)
2708
3077
# formats which have no format string are not discoverable
2709
3078
# and not independently creatable, so are not registered.
2710
3079
_legacy_formats = [WorkingTreeFormat2(),
2711
3080
                   ]
2712
 
 
2713
 
 
2714
 
class WorkingTreeTestProviderAdapter(object):
2715
 
    """A tool to generate a suite testing multiple workingtree formats at once.
2716
 
 
2717
 
    This is done by copying the test once for each transport and injecting
2718
 
    the transport_server, transport_readonly_server, and workingtree_format
2719
 
    classes into each copy. Each copy is also given a new id() to make it
2720
 
    easy to identify.
2721
 
    """
2722
 
 
2723
 
    def __init__(self, transport_server, transport_readonly_server, formats):
2724
 
        self._transport_server = transport_server
2725
 
        self._transport_readonly_server = transport_readonly_server
2726
 
        self._formats = formats
2727
 
    
2728
 
    def _clone_test(self, test, bzrdir_format, workingtree_format, variation):
2729
 
        """Clone test for adaption."""
2730
 
        new_test = deepcopy(test)
2731
 
        new_test.transport_server = self._transport_server
2732
 
        new_test.transport_readonly_server = self._transport_readonly_server
2733
 
        new_test.bzrdir_format = bzrdir_format
2734
 
        new_test.workingtree_format = workingtree_format
2735
 
        def make_new_test_id():
2736
 
            new_id = "%s(%s)" % (test.id(), variation)
2737
 
            return lambda: new_id
2738
 
        new_test.id = make_new_test_id()
2739
 
        return new_test
2740
 
    
2741
 
    def adapt(self, test):
2742
 
        from bzrlib.tests import TestSuite
2743
 
        result = TestSuite()
2744
 
        for workingtree_format, bzrdir_format in self._formats:
2745
 
            new_test = self._clone_test(
2746
 
                test,
2747
 
                bzrdir_format,
2748
 
                workingtree_format, workingtree_format.__class__.__name__)
2749
 
            result.addTest(new_test)
2750
 
        return result