/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Martin Pool
  • Date: 2006-05-08 04:39:50 UTC
  • mto: This revision was merged to the branch mainline in revision 1707.
  • Revision ID: mbp@sourcefrog.net-20060508043950-bb61b1e5ea33c349
Fix time-dependency in LockDir tests -- allow more margin for error in time to detect lock contention

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""WorkingTree object and friends.
 
18
 
 
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 
 
23
new revision based on the workingtree and its inventory.
 
24
 
 
25
At the moment every WorkingTree has its own branch.  Remote
 
26
WorkingTrees aren't supported.
 
27
 
 
28
To get a WorkingTree, call bzrdir.open_workingtree() or
 
29
WorkingTree.open(dir).
 
30
"""
 
31
 
 
32
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
 
33
CONFLICT_HEADER_1 = "BZR conflict list format 1"
 
34
 
 
35
# TODO: Give the workingtree sole responsibility for the working inventory;
 
36
# remove the variable and references to it from the branch.  This may require
 
37
# updating the commit code so as to update the inventory within the working
 
38
# copy, and making sure there's only one WorkingTree for any directory on disk.
 
39
# At the moment they may alias the inventory and have old copies of it in
 
40
# memory.  (Now done? -- mbp 20060309)
 
41
 
 
42
from copy import deepcopy
 
43
from cStringIO import StringIO
 
44
import errno
 
45
import fnmatch
 
46
import os
 
47
import stat
 
48
 
 
49
 
 
50
from bzrlib.atomicfile import AtomicFile
 
51
from bzrlib.branch import (Branch,
 
52
                           quotefn)
 
53
from bzrlib.conflicts import Conflict, ConflictList, CONFLICT_SUFFIXES
 
54
import bzrlib.bzrdir as bzrdir
 
55
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
56
import bzrlib.errors as errors
 
57
from bzrlib.errors import (BzrCheckError,
 
58
                           BzrError,
 
59
                           ConflictFormatError,
 
60
                           DivergedBranches,
 
61
                           WeaveRevisionNotPresent,
 
62
                           NotBranchError,
 
63
                           NoSuchFile,
 
64
                           NotVersionedError,
 
65
                           MergeModifiedFormatError,
 
66
                           UnsupportedOperation,
 
67
                           )
 
68
from bzrlib.inventory import InventoryEntry, Inventory
 
69
from bzrlib.lockable_files import LockableFiles, TransportLock
 
70
from bzrlib.lockdir import LockDir
 
71
from bzrlib.merge import merge_inner, transform_tree
 
72
from bzrlib.osutils import (
 
73
                            abspath,
 
74
                            appendpath,
 
75
                            compact_date,
 
76
                            file_kind,
 
77
                            isdir,
 
78
                            getcwd,
 
79
                            pathjoin,
 
80
                            pumpfile,
 
81
                            safe_unicode,
 
82
                            splitpath,
 
83
                            rand_bytes,
 
84
                            normpath,
 
85
                            realpath,
 
86
                            relpath,
 
87
                            rename,
 
88
                            supports_executable,
 
89
                            )
 
90
from bzrlib.progress import DummyProgress, ProgressPhase
 
91
from bzrlib.revision import NULL_REVISION
 
92
from bzrlib.rio import RioReader, rio_file, Stanza
 
93
from bzrlib.symbol_versioning import *
 
94
from bzrlib.textui import show_status
 
95
import bzrlib.tree
 
96
from bzrlib.transform import build_tree
 
97
from bzrlib.trace import mutter, note
 
98
from bzrlib.transport import get_transport
 
99
from bzrlib.transport.local import LocalTransport
 
100
import bzrlib.ui
 
101
import bzrlib.xml5
 
102
 
 
103
 
 
104
def gen_file_id(name):
 
105
    """Return new file id.
 
106
 
 
107
    This should probably generate proper UUIDs, but for the moment we
 
108
    cope with just randomness because running uuidgen every time is
 
109
    slow."""
 
110
    import re
 
111
    from binascii import hexlify
 
112
    from time import time
 
113
 
 
114
    # get last component
 
115
    idx = name.rfind('/')
 
116
    if idx != -1:
 
117
        name = name[idx+1 : ]
 
118
    idx = name.rfind('\\')
 
119
    if idx != -1:
 
120
        name = name[idx+1 : ]
 
121
 
 
122
    # make it not a hidden file
 
123
    name = name.lstrip('.')
 
124
 
 
125
    # remove any wierd characters; we don't escape them but rather
 
126
    # just pull them out
 
127
    name = re.sub(r'[^\w.]', '', name)
 
128
 
 
129
    s = hexlify(rand_bytes(8))
 
130
    return '-'.join((name, compact_date(time()), s))
 
131
 
 
132
 
 
133
def gen_root_id():
 
134
    """Return a new tree-root file id."""
 
135
    return gen_file_id('TREE_ROOT')
 
136
 
 
137
 
 
138
class TreeEntry(object):
 
139
    """An entry that implements the minium interface used by commands.
 
140
 
 
141
    This needs further inspection, it may be better to have 
 
142
    InventoryEntries without ids - though that seems wrong. For now,
 
143
    this is a parallel hierarchy to InventoryEntry, and needs to become
 
144
    one of several things: decorates to that hierarchy, children of, or
 
145
    parents of it.
 
146
    Another note is that these objects are currently only used when there is
 
147
    no InventoryEntry available - i.e. for unversioned objects.
 
148
    Perhaps they should be UnversionedEntry et al. ? - RBC 20051003
 
149
    """
 
150
 
 
151
    def __eq__(self, other):
 
152
        # yes, this us ugly, TODO: best practice __eq__ style.
 
153
        return (isinstance(other, TreeEntry)
 
154
                and other.__class__ == self.__class__)
 
155
 
 
156
    def kind_character(self):
 
157
        return "???"
 
158
 
 
159
 
 
160
class TreeDirectory(TreeEntry):
 
161
    """See TreeEntry. This is a directory in a working tree."""
 
162
 
 
163
    def __eq__(self, other):
 
164
        return (isinstance(other, TreeDirectory)
 
165
                and other.__class__ == self.__class__)
 
166
 
 
167
    def kind_character(self):
 
168
        return "/"
 
169
 
 
170
 
 
171
class TreeFile(TreeEntry):
 
172
    """See TreeEntry. This is a regular file in a working tree."""
 
173
 
 
174
    def __eq__(self, other):
 
175
        return (isinstance(other, TreeFile)
 
176
                and other.__class__ == self.__class__)
 
177
 
 
178
    def kind_character(self):
 
179
        return ''
 
180
 
 
181
 
 
182
class TreeLink(TreeEntry):
 
183
    """See TreeEntry. This is a symlink in a working tree."""
 
184
 
 
185
    def __eq__(self, other):
 
186
        return (isinstance(other, TreeLink)
 
187
                and other.__class__ == self.__class__)
 
188
 
 
189
    def kind_character(self):
 
190
        return ''
 
191
 
 
192
 
 
193
class WorkingTree(bzrlib.tree.Tree):
 
194
    """Working copy tree.
 
195
 
 
196
    The inventory is held in the `Branch` working-inventory, and the
 
197
    files are in a directory on disk.
 
198
 
 
199
    It is possible for a `WorkingTree` to have a filename which is
 
200
    not listed in the Inventory and vice versa.
 
201
    """
 
202
 
 
203
    def __init__(self, basedir='.',
 
204
                 branch=DEPRECATED_PARAMETER,
 
205
                 _inventory=None,
 
206
                 _control_files=None,
 
207
                 _internal=False,
 
208
                 _format=None,
 
209
                 _bzrdir=None):
 
210
        """Construct a WorkingTree for basedir.
 
211
 
 
212
        If the branch is not supplied, it is opened automatically.
 
213
        If the branch is supplied, it must be the branch for this basedir.
 
214
        (branch.base is not cross checked, because for remote branches that
 
215
        would be meaningless).
 
216
        """
 
217
        self._format = _format
 
218
        self.bzrdir = _bzrdir
 
219
        if not _internal:
 
220
            # not created via open etc.
 
221
            warn("WorkingTree() is deprecated as of bzr version 0.8. "
 
222
                 "Please use bzrdir.open_workingtree or WorkingTree.open().",
 
223
                 DeprecationWarning,
 
224
                 stacklevel=2)
 
225
            wt = WorkingTree.open(basedir)
 
226
            self._branch = wt.branch
 
227
            self.basedir = wt.basedir
 
228
            self._control_files = wt._control_files
 
229
            self._hashcache = wt._hashcache
 
230
            self._set_inventory(wt._inventory)
 
231
            self._format = wt._format
 
232
            self.bzrdir = wt.bzrdir
 
233
        from bzrlib.hashcache import HashCache
 
234
        from bzrlib.trace import note, mutter
 
235
        assert isinstance(basedir, basestring), \
 
236
            "base directory %r is not a string" % basedir
 
237
        basedir = safe_unicode(basedir)
 
238
        mutter("opening working tree %r", basedir)
 
239
        if deprecated_passed(branch):
 
240
            if not _internal:
 
241
                warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
 
242
                     " Please use bzrdir.open_workingtree() or"
 
243
                     " WorkingTree.open().",
 
244
                     DeprecationWarning,
 
245
                     stacklevel=2
 
246
                     )
 
247
            self._branch = branch
 
248
        else:
 
249
            self._branch = self.bzrdir.open_branch()
 
250
        assert isinstance(self.branch, Branch), \
 
251
            "branch %r is not a Branch" % self.branch
 
252
        self.basedir = realpath(basedir)
 
253
        # if branch is at our basedir and is a format 6 or less
 
254
        if isinstance(self._format, WorkingTreeFormat2):
 
255
            # share control object
 
256
            self._control_files = self.branch.control_files
 
257
        else:
 
258
            # only ready for format 3
 
259
            assert isinstance(self._format, WorkingTreeFormat3)
 
260
            assert isinstance(_control_files, LockableFiles), \
 
261
                    "_control_files must be a LockableFiles, not %r" \
 
262
                    % _control_files
 
263
            self._control_files = _control_files
 
264
        # update the whole cache up front and write to disk if anything changed;
 
265
        # in the future we might want to do this more selectively
 
266
        # two possible ways offer themselves : in self._unlock, write the cache
 
267
        # if needed, or, when the cache sees a change, append it to the hash
 
268
        # cache file, and have the parser take the most recent entry for a
 
269
        # given path only.
 
270
        cache_filename = self.bzrdir.get_workingtree_transport(None).abspath('stat-cache')
 
271
        hc = self._hashcache = HashCache(basedir, cache_filename, self._control_files._file_mode)
 
272
        hc.read()
 
273
        # is this scan needed ? it makes things kinda slow.
 
274
        hc.scan()
 
275
 
 
276
        if hc.needs_write:
 
277
            mutter("write hc")
 
278
            hc.write()
 
279
 
 
280
        if _inventory is None:
 
281
            self._set_inventory(self.read_working_inventory())
 
282
        else:
 
283
            self._set_inventory(_inventory)
 
284
 
 
285
    branch = property(
 
286
        fget=lambda self: self._branch,
 
287
        doc="""The branch this WorkingTree is connected to.
 
288
 
 
289
            This cannot be set - it is reflective of the actual disk structure
 
290
            the working tree has been constructed from.
 
291
            """)
 
292
 
 
293
    def break_lock(self):
 
294
        """Break a lock if one is present from another instance.
 
295
 
 
296
        Uses the ui factory to ask for confirmation if the lock may be from
 
297
        an active process.
 
298
 
 
299
        This will probe the repository for its lock as well.
 
300
        """
 
301
        self._control_files.break_lock()
 
302
        self.branch.break_lock()
 
303
 
 
304
    def _set_inventory(self, inv):
 
305
        self._inventory = inv
 
306
        self.path2id = self._inventory.path2id
 
307
 
 
308
    def is_control_filename(self, filename):
 
309
        """True if filename is the name of a control file in this tree.
 
310
        
 
311
        This is true IF and ONLY IF the filename is part of the meta data
 
312
        that bzr controls in this tree. I.E. a random .bzr directory placed
 
313
        on disk will not be a control file for this tree.
 
314
        """
 
315
        try:
 
316
            self.bzrdir.transport.relpath(self.abspath(filename))
 
317
            return True
 
318
        except errors.PathNotChild:
 
319
            return False
 
320
 
 
321
    @staticmethod
 
322
    def open(path=None, _unsupported=False):
 
323
        """Open an existing working tree at path.
 
324
 
 
325
        """
 
326
        if path is None:
 
327
            path = os.path.getcwdu()
 
328
        control = bzrdir.BzrDir.open(path, _unsupported)
 
329
        return control.open_workingtree(_unsupported)
 
330
        
 
331
    @staticmethod
 
332
    def open_containing(path=None):
 
333
        """Open an existing working tree which has its root about path.
 
334
        
 
335
        This probes for a working tree at path and searches upwards from there.
 
336
 
 
337
        Basically we keep looking up until we find the control directory or
 
338
        run into /.  If there isn't one, raises NotBranchError.
 
339
        TODO: give this a new exception.
 
340
        If there is one, it is returned, along with the unused portion of path.
 
341
        """
 
342
        if path is None:
 
343
            path = os.getcwdu()
 
344
        control, relpath = bzrdir.BzrDir.open_containing(path)
 
345
        return control.open_workingtree(), relpath
 
346
 
 
347
    @staticmethod
 
348
    def open_downlevel(path=None):
 
349
        """Open an unsupported working tree.
 
350
 
 
351
        Only intended for advanced situations like upgrading part of a bzrdir.
 
352
        """
 
353
        return WorkingTree.open(path, _unsupported=True)
 
354
 
 
355
    def __iter__(self):
 
356
        """Iterate through file_ids for this tree.
 
357
 
 
358
        file_ids are in a WorkingTree if they are in the working inventory
 
359
        and the working file exists.
 
360
        """
 
361
        inv = self._inventory
 
362
        for path, ie in inv.iter_entries():
 
363
            if bzrlib.osutils.lexists(self.abspath(path)):
 
364
                yield ie.file_id
 
365
 
 
366
    def __repr__(self):
 
367
        return "<%s of %s>" % (self.__class__.__name__,
 
368
                               getattr(self, 'basedir', None))
 
369
 
 
370
    def abspath(self, filename):
 
371
        return pathjoin(self.basedir, filename)
 
372
    
 
373
    def basis_tree(self):
 
374
        """Return RevisionTree for the current last revision."""
 
375
        revision_id = self.last_revision()
 
376
        if revision_id is not None:
 
377
            try:
 
378
                xml = self.read_basis_inventory()
 
379
                inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
380
            except NoSuchFile:
 
381
                inv = None
 
382
            if inv is not None and inv.revision_id == revision_id:
 
383
                return bzrlib.tree.RevisionTree(self.branch.repository, inv,
 
384
                                                revision_id)
 
385
        # FIXME? RBC 20060403 should we cache the inventory here ?
 
386
        return self.branch.repository.revision_tree(revision_id)
 
387
 
 
388
    @staticmethod
 
389
    @deprecated_method(zero_eight)
 
390
    def create(branch, directory):
 
391
        """Create a workingtree for branch at directory.
 
392
 
 
393
        If existing_directory already exists it must have a .bzr directory.
 
394
        If it does not exist, it will be created.
 
395
 
 
396
        This returns a new WorkingTree object for the new checkout.
 
397
 
 
398
        TODO FIXME RBC 20060124 when we have checkout formats in place this
 
399
        should accept an optional revisionid to checkout [and reject this if
 
400
        checking out into the same dir as a pre-checkout-aware branch format.]
 
401
 
 
402
        XXX: When BzrDir is present, these should be created through that 
 
403
        interface instead.
 
404
        """
 
405
        warn('delete WorkingTree.create', stacklevel=3)
 
406
        transport = get_transport(directory)
 
407
        if branch.bzrdir.root_transport.base == transport.base:
 
408
            # same dir 
 
409
            return branch.bzrdir.create_workingtree()
 
410
        # different directory, 
 
411
        # create a branch reference
 
412
        # and now a working tree.
 
413
        raise NotImplementedError
 
414
 
 
415
    @staticmethod
 
416
    @deprecated_method(zero_eight)
 
417
    def create_standalone(directory):
 
418
        """Create a checkout and a branch and a repo at directory.
 
419
 
 
420
        Directory must exist and be empty.
 
421
 
 
422
        please use BzrDir.create_standalone_workingtree
 
423
        """
 
424
        return bzrdir.BzrDir.create_standalone_workingtree(directory)
 
425
 
 
426
    def relpath(self, abs):
 
427
        """Return the local path portion from a given absolute path."""
 
428
        return relpath(self.basedir, abs)
 
429
 
 
430
    def has_filename(self, filename):
 
431
        return bzrlib.osutils.lexists(self.abspath(filename))
 
432
 
 
433
    def get_file(self, file_id):
 
434
        return self.get_file_byname(self.id2path(file_id))
 
435
 
 
436
    def get_file_byname(self, filename):
 
437
        return file(self.abspath(filename), 'rb')
 
438
 
 
439
    def get_root_id(self):
 
440
        """Return the id of this trees root"""
 
441
        inv = self.read_working_inventory()
 
442
        return inv.root.file_id
 
443
        
 
444
    def _get_store_filename(self, file_id):
 
445
        ## XXX: badly named; this is not in the store at all
 
446
        return self.abspath(self.id2path(file_id))
 
447
 
 
448
    @needs_read_lock
 
449
    def clone(self, to_bzrdir, revision_id=None, basis=None):
 
450
        """Duplicate this working tree into to_bzr, including all state.
 
451
        
 
452
        Specifically modified files are kept as modified, but
 
453
        ignored and unknown files are discarded.
 
454
 
 
455
        If you want to make a new line of development, see bzrdir.sprout()
 
456
 
 
457
        revision
 
458
            If not None, the cloned tree will have its last revision set to 
 
459
            revision, and and difference between the source trees last revision
 
460
            and this one merged in.
 
461
 
 
462
        basis
 
463
            If not None, a closer copy of a tree which may have some files in
 
464
            common, and which file content should be preferentially copied from.
 
465
        """
 
466
        # assumes the target bzr dir format is compatible.
 
467
        result = self._format.initialize(to_bzrdir)
 
468
        self.copy_content_into(result, revision_id)
 
469
        return result
 
470
 
 
471
    @needs_read_lock
 
472
    def copy_content_into(self, tree, revision_id=None):
 
473
        """Copy the current content and user files of this tree into tree."""
 
474
        if revision_id is None:
 
475
            transform_tree(tree, self)
 
476
        else:
 
477
            # TODO now merge from tree.last_revision to revision
 
478
            transform_tree(tree, self)
 
479
            tree.set_last_revision(revision_id)
 
480
 
 
481
    @needs_write_lock
 
482
    def commit(self, message=None, revprops=None, *args, **kwargs):
 
483
        # avoid circular imports
 
484
        from bzrlib.commit import Commit
 
485
        if revprops is None:
 
486
            revprops = {}
 
487
        if not 'branch-nick' in revprops:
 
488
            revprops['branch-nick'] = self.branch.nick
 
489
        # args for wt.commit start at message from the Commit.commit method,
 
490
        # but with branch a kwarg now, passing in args as is results in the
 
491
        #message being used for the branch
 
492
        args = (DEPRECATED_PARAMETER, message, ) + args
 
493
        Commit().commit(working_tree=self, revprops=revprops, *args, **kwargs)
 
494
        self._set_inventory(self.read_working_inventory())
 
495
 
 
496
    def id2abspath(self, file_id):
 
497
        return self.abspath(self.id2path(file_id))
 
498
 
 
499
    def has_id(self, file_id):
 
500
        # files that have been deleted are excluded
 
501
        inv = self._inventory
 
502
        if not inv.has_id(file_id):
 
503
            return False
 
504
        path = inv.id2path(file_id)
 
505
        return bzrlib.osutils.lexists(self.abspath(path))
 
506
 
 
507
    def has_or_had_id(self, file_id):
 
508
        if file_id == self.inventory.root.file_id:
 
509
            return True
 
510
        return self.inventory.has_id(file_id)
 
511
 
 
512
    __contains__ = has_id
 
513
 
 
514
    def get_file_size(self, file_id):
 
515
        return os.path.getsize(self.id2abspath(file_id))
 
516
 
 
517
    @needs_read_lock
 
518
    def get_file_sha1(self, file_id):
 
519
        path = self._inventory.id2path(file_id)
 
520
        return self._hashcache.get_sha1(path)
 
521
 
 
522
    def is_executable(self, file_id):
 
523
        if not supports_executable():
 
524
            return self._inventory[file_id].executable
 
525
        else:
 
526
            path = self._inventory.id2path(file_id)
 
527
            mode = os.lstat(self.abspath(path)).st_mode
 
528
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC&mode)
 
529
 
 
530
    @needs_write_lock
 
531
    def add(self, files, ids=None):
 
532
        """Make files versioned.
 
533
 
 
534
        Note that the command line normally calls smart_add instead,
 
535
        which can automatically recurse.
 
536
 
 
537
        This adds the files to the inventory, so that they will be
 
538
        recorded by the next commit.
 
539
 
 
540
        files
 
541
            List of paths to add, relative to the base of the tree.
 
542
 
 
543
        ids
 
544
            If set, use these instead of automatically generated ids.
 
545
            Must be the same length as the list of files, but may
 
546
            contain None for ids that are to be autogenerated.
 
547
 
 
548
        TODO: Perhaps have an option to add the ids even if the files do
 
549
              not (yet) exist.
 
550
 
 
551
        TODO: Perhaps callback with the ids and paths as they're added.
 
552
        """
 
553
        # TODO: Re-adding a file that is removed in the working copy
 
554
        # should probably put it back with the previous ID.
 
555
        if isinstance(files, basestring):
 
556
            assert(ids is None or isinstance(ids, basestring))
 
557
            files = [files]
 
558
            if ids is not None:
 
559
                ids = [ids]
 
560
 
 
561
        if ids is None:
 
562
            ids = [None] * len(files)
 
563
        else:
 
564
            assert(len(ids) == len(files))
 
565
 
 
566
        inv = self.read_working_inventory()
 
567
        for f,file_id in zip(files, ids):
 
568
            if self.is_control_filename(f):
 
569
                raise BzrError("cannot add control file %s" % quotefn(f))
 
570
 
 
571
            fp = splitpath(f)
 
572
 
 
573
            if len(fp) == 0:
 
574
                raise BzrError("cannot add top-level %r" % f)
 
575
 
 
576
            fullpath = normpath(self.abspath(f))
 
577
 
 
578
            try:
 
579
                kind = file_kind(fullpath)
 
580
            except OSError, e:
 
581
                if e.errno == errno.ENOENT:
 
582
                    raise NoSuchFile(fullpath)
 
583
                # maybe something better?
 
584
                raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
 
585
 
 
586
            if not InventoryEntry.versionable_kind(kind):
 
587
                raise BzrError('cannot add: not a versionable file ('
 
588
                               'i.e. regular file, symlink or directory): %s' % quotefn(f))
 
589
 
 
590
            if file_id is None:
 
591
                file_id = gen_file_id(f)
 
592
            inv.add_path(f, kind=kind, file_id=file_id)
 
593
 
 
594
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
595
        self._write_inventory(inv)
 
596
 
 
597
    @needs_write_lock
 
598
    def add_pending_merge(self, *revision_ids):
 
599
        # TODO: Perhaps should check at this point that the
 
600
        # history of the revision is actually present?
 
601
        p = self.pending_merges()
 
602
        updated = False
 
603
        for rev_id in revision_ids:
 
604
            if rev_id in p:
 
605
                continue
 
606
            p.append(rev_id)
 
607
            updated = True
 
608
        if updated:
 
609
            self.set_pending_merges(p)
 
610
 
 
611
    @needs_read_lock
 
612
    def pending_merges(self):
 
613
        """Return a list of pending merges.
 
614
 
 
615
        These are revisions that have been merged into the working
 
616
        directory but not yet committed.
 
617
        """
 
618
        try:
 
619
            merges_file = self._control_files.get_utf8('pending-merges')
 
620
        except OSError, e:
 
621
            if e.errno != errno.ENOENT:
 
622
                raise
 
623
            return []
 
624
        p = []
 
625
        for l in merges_file.readlines():
 
626
            p.append(l.rstrip('\n'))
 
627
        return p
 
628
 
 
629
    @needs_write_lock
 
630
    def set_pending_merges(self, rev_list):
 
631
        self._control_files.put_utf8('pending-merges', '\n'.join(rev_list))
 
632
 
 
633
    @needs_write_lock
 
634
    def set_merge_modified(self, modified_hashes):
 
635
        def iter_stanzas():
 
636
            for file_id, hash in modified_hashes.iteritems():
 
637
                yield Stanza(file_id=file_id, hash=hash)
 
638
        self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
 
639
 
 
640
    @needs_write_lock
 
641
    def _put_rio(self, filename, stanzas, header):
 
642
        my_file = rio_file(stanzas, header)
 
643
        self._control_files.put(filename, my_file)
 
644
 
 
645
    @needs_read_lock
 
646
    def merge_modified(self):
 
647
        try:
 
648
            hashfile = self._control_files.get('merge-hashes')
 
649
        except NoSuchFile:
 
650
            return {}
 
651
        merge_hashes = {}
 
652
        try:
 
653
            if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
 
654
                raise MergeModifiedFormatError()
 
655
        except StopIteration:
 
656
            raise MergeModifiedFormatError()
 
657
        for s in RioReader(hashfile):
 
658
            file_id = s.get("file_id")
 
659
            if file_id not in self.inventory:
 
660
                continue
 
661
            hash = s.get("hash")
 
662
            if hash == self.get_file_sha1(file_id):
 
663
                merge_hashes[file_id] = hash
 
664
        return merge_hashes
 
665
 
 
666
    def get_symlink_target(self, file_id):
 
667
        return os.readlink(self.id2abspath(file_id))
 
668
 
 
669
    def file_class(self, filename):
 
670
        if self.path2id(filename):
 
671
            return 'V'
 
672
        elif self.is_ignored(filename):
 
673
            return 'I'
 
674
        else:
 
675
            return '?'
 
676
 
 
677
    def list_files(self):
 
678
        """Recursively list all files as (path, class, kind, id).
 
679
 
 
680
        Lists, but does not descend into unversioned directories.
 
681
 
 
682
        This does not include files that have been deleted in this
 
683
        tree.
 
684
 
 
685
        Skips the control directory.
 
686
        """
 
687
        inv = self._inventory
 
688
 
 
689
        def descend(from_dir_relpath, from_dir_id, dp):
 
690
            ls = os.listdir(dp)
 
691
            ls.sort()
 
692
            for f in ls:
 
693
                ## TODO: If we find a subdirectory with its own .bzr
 
694
                ## directory, then that is a separate tree and we
 
695
                ## should exclude it.
 
696
 
 
697
                # the bzrdir for this tree
 
698
                if self.bzrdir.transport.base.endswith(f + '/'):
 
699
                    continue
 
700
 
 
701
                # path within tree
 
702
                fp = appendpath(from_dir_relpath, f)
 
703
 
 
704
                # absolute path
 
705
                fap = appendpath(dp, f)
 
706
                
 
707
                f_ie = inv.get_child(from_dir_id, f)
 
708
                if f_ie:
 
709
                    c = 'V'
 
710
                elif self.is_ignored(fp):
 
711
                    c = 'I'
 
712
                else:
 
713
                    c = '?'
 
714
 
 
715
                fk = file_kind(fap)
 
716
 
 
717
                if f_ie:
 
718
                    if f_ie.kind != fk:
 
719
                        raise BzrCheckError("file %r entered as kind %r id %r, "
 
720
                                            "now of kind %r"
 
721
                                            % (fap, f_ie.kind, f_ie.file_id, fk))
 
722
 
 
723
                # make a last minute entry
 
724
                if f_ie:
 
725
                    entry = f_ie
 
726
                else:
 
727
                    if fk == 'directory':
 
728
                        entry = TreeDirectory()
 
729
                    elif fk == 'file':
 
730
                        entry = TreeFile()
 
731
                    elif fk == 'symlink':
 
732
                        entry = TreeLink()
 
733
                    else:
 
734
                        entry = TreeEntry()
 
735
                
 
736
                yield fp, c, fk, (f_ie and f_ie.file_id), entry
 
737
 
 
738
                if fk != 'directory':
 
739
                    continue
 
740
 
 
741
                if c != 'V':
 
742
                    # don't descend unversioned directories
 
743
                    continue
 
744
                
 
745
                for ff in descend(fp, f_ie.file_id, fap):
 
746
                    yield ff
 
747
 
 
748
        for f in descend(u'', inv.root.file_id, self.basedir):
 
749
            yield f
 
750
 
 
751
    @needs_write_lock
 
752
    def move(self, from_paths, to_name):
 
753
        """Rename files.
 
754
 
 
755
        to_name must exist in the inventory.
 
756
 
 
757
        If to_name exists and is a directory, the files are moved into
 
758
        it, keeping their old names.  
 
759
 
 
760
        Note that to_name is only the last component of the new name;
 
761
        this doesn't change the directory.
 
762
 
 
763
        This returns a list of (from_path, to_path) pairs for each
 
764
        entry that is moved.
 
765
        """
 
766
        result = []
 
767
        ## TODO: Option to move IDs only
 
768
        assert not isinstance(from_paths, basestring)
 
769
        inv = self.inventory
 
770
        to_abs = self.abspath(to_name)
 
771
        if not isdir(to_abs):
 
772
            raise BzrError("destination %r is not a directory" % to_abs)
 
773
        if not self.has_filename(to_name):
 
774
            raise BzrError("destination %r not in working directory" % to_abs)
 
775
        to_dir_id = inv.path2id(to_name)
 
776
        if to_dir_id == None and to_name != '':
 
777
            raise BzrError("destination %r is not a versioned directory" % to_name)
 
778
        to_dir_ie = inv[to_dir_id]
 
779
        if to_dir_ie.kind not in ('directory', 'root_directory'):
 
780
            raise BzrError("destination %r is not a directory" % to_abs)
 
781
 
 
782
        to_idpath = inv.get_idpath(to_dir_id)
 
783
 
 
784
        for f in from_paths:
 
785
            if not self.has_filename(f):
 
786
                raise BzrError("%r does not exist in working tree" % f)
 
787
            f_id = inv.path2id(f)
 
788
            if f_id == None:
 
789
                raise BzrError("%r is not versioned" % f)
 
790
            name_tail = splitpath(f)[-1]
 
791
            dest_path = appendpath(to_name, name_tail)
 
792
            if self.has_filename(dest_path):
 
793
                raise BzrError("destination %r already exists" % dest_path)
 
794
            if f_id in to_idpath:
 
795
                raise BzrError("can't move %r to a subdirectory of itself" % f)
 
796
 
 
797
        # OK, so there's a race here, it's possible that someone will
 
798
        # create a file in this interval and then the rename might be
 
799
        # left half-done.  But we should have caught most problems.
 
800
        orig_inv = deepcopy(self.inventory)
 
801
        try:
 
802
            for f in from_paths:
 
803
                name_tail = splitpath(f)[-1]
 
804
                dest_path = appendpath(to_name, name_tail)
 
805
                result.append((f, dest_path))
 
806
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
807
                try:
 
808
                    rename(self.abspath(f), self.abspath(dest_path))
 
809
                except OSError, e:
 
810
                    raise BzrError("failed to rename %r to %r: %s" %
 
811
                                   (f, dest_path, e[1]),
 
812
                            ["rename rolled back"])
 
813
        except:
 
814
            # restore the inventory on error
 
815
            self._set_inventory(orig_inv)
 
816
            raise
 
817
        self._write_inventory(inv)
 
818
        return result
 
819
 
 
820
    @needs_write_lock
 
821
    def rename_one(self, from_rel, to_rel):
 
822
        """Rename one file.
 
823
 
 
824
        This can change the directory or the filename or both.
 
825
        """
 
826
        inv = self.inventory
 
827
        if not self.has_filename(from_rel):
 
828
            raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
829
        if self.has_filename(to_rel):
 
830
            raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
831
 
 
832
        file_id = inv.path2id(from_rel)
 
833
        if file_id == None:
 
834
            raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
835
 
 
836
        entry = inv[file_id]
 
837
        from_parent = entry.parent_id
 
838
        from_name = entry.name
 
839
        
 
840
        if inv.path2id(to_rel):
 
841
            raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
842
 
 
843
        to_dir, to_tail = os.path.split(to_rel)
 
844
        to_dir_id = inv.path2id(to_dir)
 
845
        if to_dir_id == None and to_dir != '':
 
846
            raise BzrError("can't determine destination directory id for %r" % to_dir)
 
847
 
 
848
        mutter("rename_one:")
 
849
        mutter("  file_id    {%s}" % file_id)
 
850
        mutter("  from_rel   %r" % from_rel)
 
851
        mutter("  to_rel     %r" % to_rel)
 
852
        mutter("  to_dir     %r" % to_dir)
 
853
        mutter("  to_dir_id  {%s}" % to_dir_id)
 
854
 
 
855
        inv.rename(file_id, to_dir_id, to_tail)
 
856
 
 
857
        from_abs = self.abspath(from_rel)
 
858
        to_abs = self.abspath(to_rel)
 
859
        try:
 
860
            rename(from_abs, to_abs)
 
861
        except OSError, e:
 
862
            inv.rename(file_id, from_parent, from_name)
 
863
            raise BzrError("failed to rename %r to %r: %s"
 
864
                    % (from_abs, to_abs, e[1]),
 
865
                    ["rename rolled back"])
 
866
        self._write_inventory(inv)
 
867
 
 
868
    @needs_read_lock
 
869
    def unknowns(self):
 
870
        """Return all unknown files.
 
871
 
 
872
        These are files in the working directory that are not versioned or
 
873
        control files or ignored.
 
874
        
 
875
        >>> from bzrlib.bzrdir import ScratchDir
 
876
        >>> d = ScratchDir(files=['foo', 'foo~'])
 
877
        >>> b = d.open_branch()
 
878
        >>> tree = d.open_workingtree()
 
879
        >>> map(str, tree.unknowns())
 
880
        ['foo']
 
881
        >>> tree.add('foo')
 
882
        >>> list(b.unknowns())
 
883
        []
 
884
        >>> tree.remove('foo')
 
885
        >>> list(b.unknowns())
 
886
        [u'foo']
 
887
        """
 
888
        for subp in self.extras():
 
889
            if not self.is_ignored(subp):
 
890
                yield subp
 
891
 
 
892
    @deprecated_method(zero_eight)
 
893
    def iter_conflicts(self):
 
894
        """List all files in the tree that have text or content conflicts.
 
895
        DEPRECATED.  Use conflicts instead."""
 
896
        return self._iter_conflicts()
 
897
 
 
898
    def _iter_conflicts(self):
 
899
        conflicted = set()
 
900
        for path in (s[0] for s in self.list_files()):
 
901
            stem = get_conflicted_stem(path)
 
902
            if stem is None:
 
903
                continue
 
904
            if stem not in conflicted:
 
905
                conflicted.add(stem)
 
906
                yield stem
 
907
 
 
908
    @needs_write_lock
 
909
    def pull(self, source, overwrite=False, stop_revision=None):
 
910
        top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
911
        source.lock_read()
 
912
        try:
 
913
            pp = ProgressPhase("Pull phase", 2, top_pb)
 
914
            pp.next_phase()
 
915
            old_revision_history = self.branch.revision_history()
 
916
            basis_tree = self.basis_tree()
 
917
            count = self.branch.pull(source, overwrite, stop_revision)
 
918
            new_revision_history = self.branch.revision_history()
 
919
            if new_revision_history != old_revision_history:
 
920
                pp.next_phase()
 
921
                if len(old_revision_history):
 
922
                    other_revision = old_revision_history[-1]
 
923
                else:
 
924
                    other_revision = None
 
925
                repository = self.branch.repository
 
926
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
927
                try:
 
928
                    merge_inner(self.branch,
 
929
                                self.branch.basis_tree(),
 
930
                                basis_tree, 
 
931
                                this_tree=self, 
 
932
                                pb=pb)
 
933
                finally:
 
934
                    pb.finished()
 
935
                self.set_last_revision(self.branch.last_revision())
 
936
            return count
 
937
        finally:
 
938
            source.unlock()
 
939
            top_pb.finished()
 
940
 
 
941
    def extras(self):
 
942
        """Yield all unknown files in this WorkingTree.
 
943
 
 
944
        If there are any unknown directories then only the directory is
 
945
        returned, not all its children.  But if there are unknown files
 
946
        under a versioned subdirectory, they are returned.
 
947
 
 
948
        Currently returned depth-first, sorted by name within directories.
 
949
        """
 
950
        ## TODO: Work from given directory downwards
 
951
        for path, dir_entry in self.inventory.directories():
 
952
            mutter("search for unknowns in %r", path)
 
953
            dirabs = self.abspath(path)
 
954
            if not isdir(dirabs):
 
955
                # e.g. directory deleted
 
956
                continue
 
957
 
 
958
            fl = []
 
959
            for subf in os.listdir(dirabs):
 
960
                if (subf != '.bzr'
 
961
                    and (subf not in dir_entry.children)):
 
962
                    fl.append(subf)
 
963
            
 
964
            fl.sort()
 
965
            for subf in fl:
 
966
                subp = appendpath(path, subf)
 
967
                yield subp
 
968
 
 
969
 
 
970
    def ignored_files(self):
 
971
        """Yield list of PATH, IGNORE_PATTERN"""
 
972
        for subp in self.extras():
 
973
            pat = self.is_ignored(subp)
 
974
            if pat != None:
 
975
                yield subp, pat
 
976
 
 
977
 
 
978
    def get_ignore_list(self):
 
979
        """Return list of ignore patterns.
 
980
 
 
981
        Cached in the Tree object after the first call.
 
982
        """
 
983
        if hasattr(self, '_ignorelist'):
 
984
            return self._ignorelist
 
985
 
 
986
        l = bzrlib.DEFAULT_IGNORE[:]
 
987
        if self.has_filename(bzrlib.IGNORE_FILENAME):
 
988
            f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
 
989
            l.extend([line.rstrip("\n\r") for line in f.readlines()])
 
990
        self._ignorelist = l
 
991
        return l
 
992
 
 
993
 
 
994
    def is_ignored(self, filename):
 
995
        r"""Check whether the filename matches an ignore pattern.
 
996
 
 
997
        Patterns containing '/' or '\' need to match the whole path;
 
998
        others match against only the last component.
 
999
 
 
1000
        If the file is ignored, returns the pattern which caused it to
 
1001
        be ignored, otherwise None.  So this can simply be used as a
 
1002
        boolean if desired."""
 
1003
 
 
1004
        # TODO: Use '**' to match directories, and other extended
 
1005
        # globbing stuff from cvs/rsync.
 
1006
 
 
1007
        # XXX: fnmatch is actually not quite what we want: it's only
 
1008
        # approximately the same as real Unix fnmatch, and doesn't
 
1009
        # treat dotfiles correctly and allows * to match /.
 
1010
        # Eventually it should be replaced with something more
 
1011
        # accurate.
 
1012
        
 
1013
        for pat in self.get_ignore_list():
 
1014
            if '/' in pat or '\\' in pat:
 
1015
                
 
1016
                # as a special case, you can put ./ at the start of a
 
1017
                # pattern; this is good to match in the top-level
 
1018
                # only;
 
1019
                
 
1020
                if (pat[:2] == './') or (pat[:2] == '.\\'):
 
1021
                    newpat = pat[2:]
 
1022
                else:
 
1023
                    newpat = pat
 
1024
                if fnmatch.fnmatchcase(filename, newpat):
 
1025
                    return pat
 
1026
            else:
 
1027
                if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
 
1028
                    return pat
 
1029
        else:
 
1030
            return None
 
1031
 
 
1032
    def kind(self, file_id):
 
1033
        return file_kind(self.id2abspath(file_id))
 
1034
 
 
1035
    @needs_read_lock
 
1036
    def last_revision(self):
 
1037
        """Return the last revision id of this working tree.
 
1038
 
 
1039
        In early branch formats this was == the branch last_revision,
 
1040
        but that cannot be relied upon - for working tree operations,
 
1041
        always use tree.last_revision().
 
1042
        """
 
1043
        return self.branch.last_revision()
 
1044
 
 
1045
    def is_locked(self):
 
1046
        return self._control_files.is_locked()
 
1047
 
 
1048
    def lock_read(self):
 
1049
        """See Branch.lock_read, and WorkingTree.unlock."""
 
1050
        self.branch.lock_read()
 
1051
        try:
 
1052
            return self._control_files.lock_read()
 
1053
        except:
 
1054
            self.branch.unlock()
 
1055
            raise
 
1056
 
 
1057
    def lock_write(self):
 
1058
        """See Branch.lock_write, and WorkingTree.unlock."""
 
1059
        self.branch.lock_write()
 
1060
        try:
 
1061
            return self._control_files.lock_write()
 
1062
        except:
 
1063
            self.branch.unlock()
 
1064
            raise
 
1065
 
 
1066
    def get_physical_lock_status(self):
 
1067
        return self._control_files.get_physical_lock_status()
 
1068
 
 
1069
    def _basis_inventory_name(self):
 
1070
        return 'basis-inventory'
 
1071
 
 
1072
    @needs_write_lock
 
1073
    def set_last_revision(self, new_revision):
 
1074
        """Change the last revision in the working tree."""
 
1075
        if self._change_last_revision(new_revision):
 
1076
            self._cache_basis_inventory(new_revision)
 
1077
 
 
1078
    def _change_last_revision(self, new_revision):
 
1079
        """Template method part of set_last_revision to perform the change.
 
1080
        
 
1081
        This is used to allow WorkingTree3 instances to not affect branch
 
1082
        when their last revision is set.
 
1083
        """
 
1084
        if new_revision is None:
 
1085
            self.branch.set_revision_history([])
 
1086
            return False
 
1087
        # current format is locked in with the branch
 
1088
        revision_history = self.branch.revision_history()
 
1089
        try:
 
1090
            position = revision_history.index(new_revision)
 
1091
        except ValueError:
 
1092
            raise errors.NoSuchRevision(self.branch, new_revision)
 
1093
        self.branch.set_revision_history(revision_history[:position + 1])
 
1094
        return True
 
1095
 
 
1096
    def _cache_basis_inventory(self, new_revision):
 
1097
        """Cache new_revision as the basis inventory."""
 
1098
        try:
 
1099
            # this double handles the inventory - unpack and repack - 
 
1100
            # but is easier to understand. We can/should put a conditional
 
1101
            # in here based on whether the inventory is in the latest format
 
1102
            # - perhaps we should repack all inventories on a repository
 
1103
            # upgrade ?
 
1104
            inv = self.branch.repository.get_inventory(new_revision)
 
1105
            inv.revision_id = new_revision
 
1106
            xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
 
1107
 
 
1108
            path = self._basis_inventory_name()
 
1109
            self._control_files.put_utf8(path, xml)
 
1110
        except WeaveRevisionNotPresent:
 
1111
            pass
 
1112
 
 
1113
    def read_basis_inventory(self):
 
1114
        """Read the cached basis inventory."""
 
1115
        path = self._basis_inventory_name()
 
1116
        return self._control_files.get_utf8(path).read()
 
1117
        
 
1118
    @needs_read_lock
 
1119
    def read_working_inventory(self):
 
1120
        """Read the working inventory."""
 
1121
        # ElementTree does its own conversion from UTF-8, so open in
 
1122
        # binary.
 
1123
        result = bzrlib.xml5.serializer_v5.read_inventory(
 
1124
            self._control_files.get('inventory'))
 
1125
        self._set_inventory(result)
 
1126
        return result
 
1127
 
 
1128
    @needs_write_lock
 
1129
    def remove(self, files, verbose=False):
 
1130
        """Remove nominated files from the working inventory..
 
1131
 
 
1132
        This does not remove their text.  This does not run on XXX on what? RBC
 
1133
 
 
1134
        TODO: Refuse to remove modified files unless --force is given?
 
1135
 
 
1136
        TODO: Do something useful with directories.
 
1137
 
 
1138
        TODO: Should this remove the text or not?  Tough call; not
 
1139
        removing may be useful and the user can just use use rm, and
 
1140
        is the opposite of add.  Removing it is consistent with most
 
1141
        other tools.  Maybe an option.
 
1142
        """
 
1143
        ## TODO: Normalize names
 
1144
        ## TODO: Remove nested loops; better scalability
 
1145
        if isinstance(files, basestring):
 
1146
            files = [files]
 
1147
 
 
1148
        inv = self.inventory
 
1149
 
 
1150
        # do this before any modifications
 
1151
        for f in files:
 
1152
            fid = inv.path2id(f)
 
1153
            if not fid:
 
1154
                # TODO: Perhaps make this just a warning, and continue?
 
1155
                # This tends to happen when 
 
1156
                raise NotVersionedError(path=f)
 
1157
            mutter("remove inventory entry %s {%s}", quotefn(f), fid)
 
1158
            if verbose:
 
1159
                # having remove it, it must be either ignored or unknown
 
1160
                if self.is_ignored(f):
 
1161
                    new_status = 'I'
 
1162
                else:
 
1163
                    new_status = '?'
 
1164
                show_status(new_status, inv[fid].kind, quotefn(f))
 
1165
            del inv[fid]
 
1166
 
 
1167
        self._write_inventory(inv)
 
1168
 
 
1169
    @needs_write_lock
 
1170
    def revert(self, filenames, old_tree=None, backups=True, 
 
1171
               pb=DummyProgress()):
 
1172
        from transform import revert
 
1173
        from conflicts import resolve
 
1174
        if old_tree is None:
 
1175
            old_tree = self.basis_tree()
 
1176
        conflicts = revert(self, old_tree, filenames, backups, pb)
 
1177
        if not len(filenames):
 
1178
            self.set_pending_merges([])
 
1179
            resolve(self)
 
1180
        else:
 
1181
            resolve(self, filenames, ignore_misses=True)
 
1182
        return conflicts
 
1183
 
 
1184
    # XXX: This method should be deprecated in favour of taking in a proper
 
1185
    # new Inventory object.
 
1186
    @needs_write_lock
 
1187
    def set_inventory(self, new_inventory_list):
 
1188
        from bzrlib.inventory import (Inventory,
 
1189
                                      InventoryDirectory,
 
1190
                                      InventoryEntry,
 
1191
                                      InventoryFile,
 
1192
                                      InventoryLink)
 
1193
        inv = Inventory(self.get_root_id())
 
1194
        for path, file_id, parent, kind in new_inventory_list:
 
1195
            name = os.path.basename(path)
 
1196
            if name == "":
 
1197
                continue
 
1198
            # fixme, there should be a factory function inv,add_?? 
 
1199
            if kind == 'directory':
 
1200
                inv.add(InventoryDirectory(file_id, name, parent))
 
1201
            elif kind == 'file':
 
1202
                inv.add(InventoryFile(file_id, name, parent))
 
1203
            elif kind == 'symlink':
 
1204
                inv.add(InventoryLink(file_id, name, parent))
 
1205
            else:
 
1206
                raise BzrError("unknown kind %r" % kind)
 
1207
        self._write_inventory(inv)
 
1208
 
 
1209
    @needs_write_lock
 
1210
    def set_root_id(self, file_id):
 
1211
        """Set the root id for this tree."""
 
1212
        inv = self.read_working_inventory()
 
1213
        orig_root_id = inv.root.file_id
 
1214
        del inv._byid[inv.root.file_id]
 
1215
        inv.root.file_id = file_id
 
1216
        inv._byid[inv.root.file_id] = inv.root
 
1217
        for fid in inv:
 
1218
            entry = inv[fid]
 
1219
            if entry.parent_id == orig_root_id:
 
1220
                entry.parent_id = inv.root.file_id
 
1221
        self._write_inventory(inv)
 
1222
 
 
1223
    def unlock(self):
 
1224
        """See Branch.unlock.
 
1225
        
 
1226
        WorkingTree locking just uses the Branch locking facilities.
 
1227
        This is current because all working trees have an embedded branch
 
1228
        within them. IF in the future, we were to make branch data shareable
 
1229
        between multiple working trees, i.e. via shared storage, then we 
 
1230
        would probably want to lock both the local tree, and the branch.
 
1231
        """
 
1232
        # FIXME: We want to write out the hashcache only when the last lock on
 
1233
        # this working copy is released.  Peeking at the lock count is a bit
 
1234
        # of a nasty hack; probably it's better to have a transaction object,
 
1235
        # which can do some finalization when it's either successfully or
 
1236
        # unsuccessfully completed.  (Denys's original patch did that.)
 
1237
        # RBC 20060206 hookinhg into transaction will couple lock and transaction
 
1238
        # wrongly. Hookinh into unllock on the control files object is fine though.
 
1239
        
 
1240
        # TODO: split this per format so there is no ugly if block
 
1241
        if self._hashcache.needs_write and (
 
1242
            # dedicated lock files
 
1243
            self._control_files._lock_count==1 or 
 
1244
            # shared lock files
 
1245
            (self._control_files is self.branch.control_files and 
 
1246
             self._control_files._lock_count==3)):
 
1247
            self._hashcache.write()
 
1248
        # reverse order of locking.
 
1249
        try:
 
1250
            return self._control_files.unlock()
 
1251
        finally:
 
1252
            self.branch.unlock()
 
1253
 
 
1254
    @needs_write_lock
 
1255
    def update(self):
 
1256
        """Update a working tree along its branch.
 
1257
 
 
1258
        This will update the branch if its bound too, which means we have multiple trees involved:
 
1259
        The new basis tree of the master.
 
1260
        The old basis tree of the branch.
 
1261
        The old basis tree of the working tree.
 
1262
        The current working tree state.
 
1263
        pathologically all three may be different, and non ancestors of each other.
 
1264
        Conceptually we want to:
 
1265
        Preserve the wt.basis->wt.state changes
 
1266
        Transform the wt.basis to the new master basis.
 
1267
        Apply a merge of the old branch basis to get any 'local' changes from it into the tree.
 
1268
        Restore the wt.basis->wt.state changes.
 
1269
 
 
1270
        There isn't a single operation at the moment to do that, so we:
 
1271
        Merge current state -> basis tree of the master w.r.t. the old tree basis.
 
1272
        Do a 'normal' merge of the old branch basis if it is relevant.
 
1273
        """
 
1274
        old_tip = self.branch.update()
 
1275
        if old_tip is not None:
 
1276
            self.add_pending_merge(old_tip)
 
1277
        self.branch.lock_read()
 
1278
        try:
 
1279
            result = 0
 
1280
            if self.last_revision() != self.branch.last_revision():
 
1281
                # merge tree state up to new branch tip.
 
1282
                basis = self.basis_tree()
 
1283
                to_tree = self.branch.basis_tree()
 
1284
                result += merge_inner(self.branch,
 
1285
                                      to_tree,
 
1286
                                      basis,
 
1287
                                      this_tree=self)
 
1288
                self.set_last_revision(self.branch.last_revision())
 
1289
            if old_tip and old_tip != self.last_revision():
 
1290
                # our last revision was not the prior branch last reivison
 
1291
                # and we have converted that last revision to a pending merge.
 
1292
                # base is somewhere between the branch tip now
 
1293
                # and the now pending merge
 
1294
                from bzrlib.revision import common_ancestor
 
1295
                try:
 
1296
                    base_rev_id = common_ancestor(self.branch.last_revision(),
 
1297
                                                  old_tip,
 
1298
                                                  self.branch.repository)
 
1299
                except errors.NoCommonAncestor:
 
1300
                    base_rev_id = None
 
1301
                base_tree = self.branch.repository.revision_tree(base_rev_id)
 
1302
                other_tree = self.branch.repository.revision_tree(old_tip)
 
1303
                result += merge_inner(self.branch,
 
1304
                                      other_tree,
 
1305
                                      base_tree,
 
1306
                                      this_tree=self)
 
1307
            return result
 
1308
        finally:
 
1309
            self.branch.unlock()
 
1310
 
 
1311
    @needs_write_lock
 
1312
    def _write_inventory(self, inv):
 
1313
        """Write inventory as the current inventory."""
 
1314
        sio = StringIO()
 
1315
        bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
 
1316
        sio.seek(0)
 
1317
        self._control_files.put('inventory', sio)
 
1318
        self._set_inventory(inv)
 
1319
        mutter('wrote working inventory')
 
1320
 
 
1321
    def set_conflicts(self, arg):
 
1322
        raise UnsupportedOperation(self.set_conflicts, self)
 
1323
 
 
1324
    @needs_read_lock
 
1325
    def conflicts(self):
 
1326
        conflicts = ConflictList()
 
1327
        for conflicted in self._iter_conflicts():
 
1328
            text = True
 
1329
            try:
 
1330
                if file_kind(self.abspath(conflicted)) != "file":
 
1331
                    text = False
 
1332
            except OSError, e:
 
1333
                if e.errno == errno.ENOENT:
 
1334
                    text = False
 
1335
                else:
 
1336
                    raise
 
1337
            if text is True:
 
1338
                for suffix in ('.THIS', '.OTHER'):
 
1339
                    try:
 
1340
                        kind = file_kind(self.abspath(conflicted+suffix))
 
1341
                    except OSError, e:
 
1342
                        if e.errno == errno.ENOENT:
 
1343
                            text = False
 
1344
                            break
 
1345
                        else:
 
1346
                            raise
 
1347
                    if kind != "file":
 
1348
                        text = False
 
1349
                        break
 
1350
            ctype = {True: 'text conflict', False: 'contents conflict'}[text]
 
1351
            conflicts.append(Conflict.factory(ctype, path=conflicted,
 
1352
                             file_id=self.path2id(conflicted)))
 
1353
        return conflicts
 
1354
 
 
1355
 
 
1356
class WorkingTree3(WorkingTree):
 
1357
    """This is the Format 3 working tree.
 
1358
 
 
1359
    This differs from the base WorkingTree by:
 
1360
     - having its own file lock
 
1361
     - having its own last-revision property.
 
1362
 
 
1363
    This is new in bzr 0.8
 
1364
    """
 
1365
 
 
1366
    @needs_read_lock
 
1367
    def last_revision(self):
 
1368
        """See WorkingTree.last_revision."""
 
1369
        try:
 
1370
            return self._control_files.get_utf8('last-revision').read()
 
1371
        except NoSuchFile:
 
1372
            return None
 
1373
 
 
1374
    def _change_last_revision(self, revision_id):
 
1375
        """See WorkingTree._change_last_revision."""
 
1376
        if revision_id is None or revision_id == NULL_REVISION:
 
1377
            try:
 
1378
                self._control_files._transport.delete('last-revision')
 
1379
            except errors.NoSuchFile:
 
1380
                pass
 
1381
            return False
 
1382
        else:
 
1383
            try:
 
1384
                self.branch.revision_history().index(revision_id)
 
1385
            except ValueError:
 
1386
                raise errors.NoSuchRevision(self.branch, revision_id)
 
1387
            self._control_files.put_utf8('last-revision', revision_id)
 
1388
            return True
 
1389
 
 
1390
    @needs_write_lock
 
1391
    def set_conflicts(self, conflicts):
 
1392
        self._put_rio('conflicts', conflicts.to_stanzas(), 
 
1393
                      CONFLICT_HEADER_1)
 
1394
 
 
1395
    @needs_read_lock
 
1396
    def conflicts(self):
 
1397
        try:
 
1398
            confile = self._control_files.get('conflicts')
 
1399
        except NoSuchFile:
 
1400
            return ConflictList()
 
1401
        try:
 
1402
            if confile.next() != CONFLICT_HEADER_1 + '\n':
 
1403
                raise ConflictFormatError()
 
1404
        except StopIteration:
 
1405
            raise ConflictFormatError()
 
1406
        return ConflictList.from_stanzas(RioReader(confile))
 
1407
 
 
1408
 
 
1409
def get_conflicted_stem(path):
 
1410
    for suffix in CONFLICT_SUFFIXES:
 
1411
        if path.endswith(suffix):
 
1412
            return path[:-len(suffix)]
 
1413
 
 
1414
@deprecated_function(zero_eight)
 
1415
def is_control_file(filename):
 
1416
    """See WorkingTree.is_control_filename(filename)."""
 
1417
    ## FIXME: better check
 
1418
    filename = normpath(filename)
 
1419
    while filename != '':
 
1420
        head, tail = os.path.split(filename)
 
1421
        ## mutter('check %r for control file' % ((head, tail),))
 
1422
        if tail == '.bzr':
 
1423
            return True
 
1424
        if filename == head:
 
1425
            break
 
1426
        filename = head
 
1427
    return False
 
1428
 
 
1429
 
 
1430
class WorkingTreeFormat(object):
 
1431
    """An encapsulation of the initialization and open routines for a format.
 
1432
 
 
1433
    Formats provide three things:
 
1434
     * An initialization routine,
 
1435
     * a format string,
 
1436
     * an open routine.
 
1437
 
 
1438
    Formats are placed in an dict by their format string for reference 
 
1439
    during workingtree opening. Its not required that these be instances, they
 
1440
    can be classes themselves with class methods - it simply depends on 
 
1441
    whether state is needed for a given format or not.
 
1442
 
 
1443
    Once a format is deprecated, just deprecate the initialize and open
 
1444
    methods on the format class. Do not deprecate the object, as the 
 
1445
    object will be created every time regardless.
 
1446
    """
 
1447
 
 
1448
    _default_format = None
 
1449
    """The default format used for new trees."""
 
1450
 
 
1451
    _formats = {}
 
1452
    """The known formats."""
 
1453
 
 
1454
    @classmethod
 
1455
    def find_format(klass, a_bzrdir):
 
1456
        """Return the format for the working tree object in a_bzrdir."""
 
1457
        try:
 
1458
            transport = a_bzrdir.get_workingtree_transport(None)
 
1459
            format_string = transport.get("format").read()
 
1460
            return klass._formats[format_string]
 
1461
        except NoSuchFile:
 
1462
            raise errors.NoWorkingTree(base=transport.base)
 
1463
        except KeyError:
 
1464
            raise errors.UnknownFormatError(format_string)
 
1465
 
 
1466
    @classmethod
 
1467
    def get_default_format(klass):
 
1468
        """Return the current default format."""
 
1469
        return klass._default_format
 
1470
 
 
1471
    def get_format_string(self):
 
1472
        """Return the ASCII format string that identifies this format."""
 
1473
        raise NotImplementedError(self.get_format_string)
 
1474
 
 
1475
    def get_format_description(self):
 
1476
        """Return the short description for this format."""
 
1477
        raise NotImplementedError(self.get_format_description)
 
1478
 
 
1479
    def is_supported(self):
 
1480
        """Is this format supported?
 
1481
 
 
1482
        Supported formats can be initialized and opened.
 
1483
        Unsupported formats may not support initialization or committing or 
 
1484
        some other features depending on the reason for not being supported.
 
1485
        """
 
1486
        return True
 
1487
 
 
1488
    @classmethod
 
1489
    def register_format(klass, format):
 
1490
        klass._formats[format.get_format_string()] = format
 
1491
 
 
1492
    @classmethod
 
1493
    def set_default_format(klass, format):
 
1494
        klass._default_format = format
 
1495
 
 
1496
    @classmethod
 
1497
    def unregister_format(klass, format):
 
1498
        assert klass._formats[format.get_format_string()] is format
 
1499
        del klass._formats[format.get_format_string()]
 
1500
 
 
1501
 
 
1502
 
 
1503
class WorkingTreeFormat2(WorkingTreeFormat):
 
1504
    """The second working tree format. 
 
1505
 
 
1506
    This format modified the hash cache from the format 1 hash cache.
 
1507
    """
 
1508
 
 
1509
    def get_format_description(self):
 
1510
        """See WorkingTreeFormat.get_format_description()."""
 
1511
        return "Working tree format 2"
 
1512
 
 
1513
    def stub_initialize_remote(self, control_files):
 
1514
        """As a special workaround create critical control files for a remote working tree
 
1515
        
 
1516
        This ensures that it can later be updated and dealt with locally,
 
1517
        since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with 
 
1518
        no working tree.  (See bug #43064).
 
1519
        """
 
1520
        sio = StringIO()
 
1521
        inv = Inventory()
 
1522
        bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
 
1523
        sio.seek(0)
 
1524
        control_files.put('inventory', sio)
 
1525
 
 
1526
        control_files.put_utf8('pending-merges', '')
 
1527
        
 
1528
 
 
1529
    def initialize(self, a_bzrdir, revision_id=None):
 
1530
        """See WorkingTreeFormat.initialize()."""
 
1531
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1532
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1533
        branch = a_bzrdir.open_branch()
 
1534
        if revision_id is not None:
 
1535
            branch.lock_write()
 
1536
            try:
 
1537
                revision_history = branch.revision_history()
 
1538
                try:
 
1539
                    position = revision_history.index(revision_id)
 
1540
                except ValueError:
 
1541
                    raise errors.NoSuchRevision(branch, revision_id)
 
1542
                branch.set_revision_history(revision_history[:position + 1])
 
1543
            finally:
 
1544
                branch.unlock()
 
1545
        revision = branch.last_revision()
 
1546
        inv = Inventory() 
 
1547
        wt = WorkingTree(a_bzrdir.root_transport.base,
 
1548
                         branch,
 
1549
                         inv,
 
1550
                         _internal=True,
 
1551
                         _format=self,
 
1552
                         _bzrdir=a_bzrdir)
 
1553
        wt._write_inventory(inv)
 
1554
        wt.set_root_id(inv.root.file_id)
 
1555
        wt.set_last_revision(revision)
 
1556
        wt.set_pending_merges([])
 
1557
        build_tree(wt.basis_tree(), wt)
 
1558
        return wt
 
1559
 
 
1560
    def __init__(self):
 
1561
        super(WorkingTreeFormat2, self).__init__()
 
1562
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
 
1563
 
 
1564
    def open(self, a_bzrdir, _found=False):
 
1565
        """Return the WorkingTree object for a_bzrdir
 
1566
 
 
1567
        _found is a private parameter, do not use it. It is used to indicate
 
1568
               if format probing has already been done.
 
1569
        """
 
1570
        if not _found:
 
1571
            # we are being called directly and must probe.
 
1572
            raise NotImplementedError
 
1573
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1574
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1575
        return WorkingTree(a_bzrdir.root_transport.base,
 
1576
                           _internal=True,
 
1577
                           _format=self,
 
1578
                           _bzrdir=a_bzrdir)
 
1579
 
 
1580
 
 
1581
class WorkingTreeFormat3(WorkingTreeFormat):
 
1582
    """The second working tree format updated to record a format marker.
 
1583
 
 
1584
    This format:
 
1585
        - exists within a metadir controlling .bzr
 
1586
        - includes an explicit version marker for the workingtree control
 
1587
          files, separate from the BzrDir format
 
1588
        - modifies the hash cache format
 
1589
        - is new in bzr 0.8
 
1590
        - uses a LockDir to guard access to the repository
 
1591
    """
 
1592
 
 
1593
    def get_format_string(self):
 
1594
        """See WorkingTreeFormat.get_format_string()."""
 
1595
        return "Bazaar-NG Working Tree format 3"
 
1596
 
 
1597
    def get_format_description(self):
 
1598
        """See WorkingTreeFormat.get_format_description()."""
 
1599
        return "Working tree format 3"
 
1600
 
 
1601
    _lock_file_name = 'lock'
 
1602
    _lock_class = LockDir
 
1603
 
 
1604
    def _open_control_files(self, a_bzrdir):
 
1605
        transport = a_bzrdir.get_workingtree_transport(None)
 
1606
        return LockableFiles(transport, self._lock_file_name, 
 
1607
                             self._lock_class)
 
1608
 
 
1609
    def initialize(self, a_bzrdir, revision_id=None):
 
1610
        """See WorkingTreeFormat.initialize().
 
1611
        
 
1612
        revision_id allows creating a working tree at a differnet
 
1613
        revision than the branch is at.
 
1614
        """
 
1615
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1616
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1617
        transport = a_bzrdir.get_workingtree_transport(self)
 
1618
        control_files = self._open_control_files(a_bzrdir)
 
1619
        control_files.create_lock()
 
1620
        control_files.lock_write()
 
1621
        control_files.put_utf8('format', self.get_format_string())
 
1622
        branch = a_bzrdir.open_branch()
 
1623
        if revision_id is None:
 
1624
            revision_id = branch.last_revision()
 
1625
        inv = Inventory() 
 
1626
        wt = WorkingTree3(a_bzrdir.root_transport.base,
 
1627
                         branch,
 
1628
                         inv,
 
1629
                         _internal=True,
 
1630
                         _format=self,
 
1631
                         _bzrdir=a_bzrdir,
 
1632
                         _control_files=control_files)
 
1633
        wt.lock_write()
 
1634
        try:
 
1635
            wt._write_inventory(inv)
 
1636
            wt.set_root_id(inv.root.file_id)
 
1637
            wt.set_last_revision(revision_id)
 
1638
            wt.set_pending_merges([])
 
1639
            build_tree(wt.basis_tree(), wt)
 
1640
        finally:
 
1641
            wt.unlock()
 
1642
            control_files.unlock()
 
1643
        return wt
 
1644
 
 
1645
    def __init__(self):
 
1646
        super(WorkingTreeFormat3, self).__init__()
 
1647
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1648
 
 
1649
    def open(self, a_bzrdir, _found=False):
 
1650
        """Return the WorkingTree object for a_bzrdir
 
1651
 
 
1652
        _found is a private parameter, do not use it. It is used to indicate
 
1653
               if format probing has already been done.
 
1654
        """
 
1655
        if not _found:
 
1656
            # we are being called directly and must probe.
 
1657
            raise NotImplementedError
 
1658
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1659
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1660
        control_files = self._open_control_files(a_bzrdir)
 
1661
        return WorkingTree3(a_bzrdir.root_transport.base,
 
1662
                           _internal=True,
 
1663
                           _format=self,
 
1664
                           _bzrdir=a_bzrdir,
 
1665
                           _control_files=control_files)
 
1666
 
 
1667
    def __str__(self):
 
1668
        return self.get_format_string()
 
1669
 
 
1670
 
 
1671
# formats which have no format string are not discoverable
 
1672
# and not independently creatable, so are not registered.
 
1673
__default_format = WorkingTreeFormat3()
 
1674
WorkingTreeFormat.register_format(__default_format)
 
1675
WorkingTreeFormat.set_default_format(__default_format)
 
1676
_legacy_formats = [WorkingTreeFormat2(),
 
1677
                   ]
 
1678
 
 
1679
 
 
1680
class WorkingTreeTestProviderAdapter(object):
 
1681
    """A tool to generate a suite testing multiple workingtree formats at once.
 
1682
 
 
1683
    This is done by copying the test once for each transport and injecting
 
1684
    the transport_server, transport_readonly_server, and workingtree_format
 
1685
    classes into each copy. Each copy is also given a new id() to make it
 
1686
    easy to identify.
 
1687
    """
 
1688
 
 
1689
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1690
        self._transport_server = transport_server
 
1691
        self._transport_readonly_server = transport_readonly_server
 
1692
        self._formats = formats
 
1693
    
 
1694
    def adapt(self, test):
 
1695
        from bzrlib.tests import TestSuite
 
1696
        result = TestSuite()
 
1697
        for workingtree_format, bzrdir_format in self._formats:
 
1698
            new_test = deepcopy(test)
 
1699
            new_test.transport_server = self._transport_server
 
1700
            new_test.transport_readonly_server = self._transport_readonly_server
 
1701
            new_test.bzrdir_format = bzrdir_format
 
1702
            new_test.workingtree_format = workingtree_format
 
1703
            def make_new_test_id():
 
1704
                new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
 
1705
                return lambda: new_id
 
1706
            new_test.id = make_new_test_id()
 
1707
            result.addTest(new_test)
 
1708
        return result