~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Aaron Bentley
  • Date: 2006-04-07 04:46:31 UTC
  • mto: This revision was merged to the branch mainline in revision 1645.
  • Revision ID: aaron.bentley@utoronto.ca-20060407044631-f81fdd5f9fb420a6
Fix note implementation

Show diffs side-by-side

added added

removed removed

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