/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Robert Collins
  • Date: 2010-05-04 06:22:51 UTC
  • mto: This revision was merged to the branch mainline in revision 5206.
  • Revision ID: robertc@robertcollins.net-20100504062251-1ocjhrl53mum9ehw
Minor local_abspath docstring improvement.

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