~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Robert Collins
  • Date: 2006-02-28 04:31:50 UTC
  • mto: This revision was merged to the branch mainline in revision 1583.
  • Revision ID: robertc@robertcollins.net-20060228043150-fdb9c7f7231b271b
Bugfix aliases to be backwards compatible with plugins providing command.run_argv.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005 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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
29
29
WorkingTree.open(dir).
30
30
"""
31
31
 
32
 
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
33
 
CONFLICT_HEADER_1 = "BZR conflict list format 1"
 
32
 
 
33
# FIXME: I don't know if writing out the cache from the destructor is really a
 
34
# good idea, because destructors are considered poor taste in Python, and it's
 
35
# not predictable when it will be written out.
34
36
 
35
37
# TODO: Give the workingtree sole responsibility for the working inventory;
36
38
# remove the variable and references to it from the branch.  This may require
37
39
# updating the commit code so as to update the inventory within the working
38
40
# 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
# At the momenthey may alias the inventory and have old copies of it in memory.
41
42
 
42
 
from binascii import hexlify
43
 
import collections
44
43
from copy import deepcopy
45
44
from cStringIO import StringIO
46
45
import errno
47
46
import fnmatch
48
47
import os
49
 
import re
50
48
import stat
51
 
from time import time
52
 
import warnings
 
49
 
53
50
 
54
 
import bzrlib
55
 
from bzrlib import bzrdir, errors, ignores, osutils, urlutils
56
51
from bzrlib.atomicfile import AtomicFile
57
 
import bzrlib.branch
58
 
from bzrlib.conflicts import Conflict, ConflictList, CONFLICT_SUFFIXES
 
52
from bzrlib.branch import (Branch,
 
53
                           quotefn)
 
54
import bzrlib.bzrdir as bzrdir
59
55
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
56
import bzrlib.errors as errors
60
57
from bzrlib.errors import (BzrCheckError,
61
58
                           BzrError,
62
 
                           ConflictFormatError,
 
59
                           DivergedBranches,
63
60
                           WeaveRevisionNotPresent,
64
61
                           NotBranchError,
65
62
                           NoSuchFile,
66
 
                           NotVersionedError,
67
 
                           MergeModifiedFormatError,
68
 
                           UnsupportedOperation,
69
 
                           )
 
63
                           NotVersionedError)
70
64
from bzrlib.inventory import InventoryEntry, Inventory
71
 
from bzrlib.lockable_files import LockableFiles, TransportLock
72
 
from bzrlib.lockdir import LockDir
 
65
from bzrlib.lockable_files import LockableFiles
73
66
from bzrlib.merge import merge_inner, transform_tree
74
 
import bzrlib.mutabletree
75
 
from bzrlib.mutabletree import needs_tree_write_lock
76
 
from bzrlib.osutils import (
77
 
                            abspath,
 
67
from bzrlib.osutils import (appendpath,
78
68
                            compact_date,
79
69
                            file_kind,
80
70
                            isdir,
83
73
                            pumpfile,
84
74
                            safe_unicode,
85
75
                            splitpath,
86
 
                            rand_chars,
 
76
                            rand_bytes,
 
77
                            abspath,
87
78
                            normpath,
88
79
                            realpath,
89
80
                            relpath,
90
81
                            rename,
91
82
                            supports_executable,
92
83
                            )
93
 
from bzrlib.progress import DummyProgress, ProgressPhase
 
84
from bzrlib.progress import DummyProgress
94
85
from bzrlib.revision import NULL_REVISION
95
 
import bzrlib.revisiontree
96
 
from bzrlib.rio import RioReader, rio_file, Stanza
97
 
from bzrlib.symbol_versioning import (deprecated_passed,
98
 
        deprecated_method,
99
 
        deprecated_function,
100
 
        DEPRECATED_PARAMETER,
101
 
        zero_eight,
102
 
        zero_eleven,
103
 
        )
104
 
from bzrlib.trace import mutter, note
 
86
from bzrlib.symbol_versioning import *
 
87
from bzrlib.textui import show_status
 
88
import bzrlib.tree
 
89
from bzrlib.trace import mutter
105
90
from bzrlib.transform import build_tree
106
91
from bzrlib.transport import get_transport
107
92
from bzrlib.transport.local import LocalTransport
108
 
from bzrlib.textui import show_status
109
93
import bzrlib.ui
110
94
import bzrlib.xml5
111
95
 
112
96
 
113
 
# the regex removes any weird characters; we don't escape them 
114
 
# but rather just pull them out
115
 
_gen_file_id_re = re.compile(r'[^\w.]')
116
 
_gen_id_suffix = None
117
 
_gen_id_serial = 0
118
 
 
119
 
 
120
 
def _next_id_suffix():
121
 
    """Create a new file id suffix that is reasonably unique.
122
 
    
123
 
    On the first call we combine the current time with 64 bits of randomness
124
 
    to give a highly probably globally unique number. Then each call in the same
125
 
    process adds 1 to a serial number we append to that unique value.
126
 
    """
127
 
    # XXX TODO: change bzrlib.add.smart_add to call workingtree.add() rather 
128
 
    # than having to move the id randomness out of the inner loop like this.
129
 
    # XXX TODO: for the global randomness this uses we should add the thread-id
130
 
    # before the serial #.
131
 
    global _gen_id_suffix, _gen_id_serial
132
 
    if _gen_id_suffix is None:
133
 
        _gen_id_suffix = "-%s-%s-" % (compact_date(time()), rand_chars(16))
134
 
    _gen_id_serial += 1
135
 
    return _gen_id_suffix + str(_gen_id_serial)
136
 
 
137
 
 
138
97
def gen_file_id(name):
139
 
    """Return new file id for the basename 'name'.
140
 
 
141
 
    The uniqueness is supplied from _next_id_suffix.
142
 
    """
143
 
    # The real randomness is in the _next_id_suffix, the
144
 
    # rest of the identifier is just to be nice.
145
 
    # So we:
146
 
    # 1) Remove non-ascii word characters to keep the ids portable
147
 
    # 2) squash to lowercase, so the file id doesn't have to
148
 
    #    be escaped (case insensitive filesystems would bork for ids
149
 
    #    that only differred in case without escaping).
150
 
    # 3) truncate the filename to 20 chars. Long filenames also bork on some
151
 
    #    filesystems
152
 
    # 4) Removing starting '.' characters to prevent the file ids from
153
 
    #    being considered hidden.
154
 
    ascii_word_only = _gen_file_id_re.sub('', name.lower())
155
 
    short_no_dots = ascii_word_only.lstrip('.')[:20]
156
 
    return short_no_dots + _next_id_suffix()
 
98
    """Return new file id.
 
99
 
 
100
    This should probably generate proper UUIDs, but for the moment we
 
101
    cope with just randomness because running uuidgen every time is
 
102
    slow."""
 
103
    import re
 
104
    from binascii import hexlify
 
105
    from time import time
 
106
 
 
107
    # get last component
 
108
    idx = name.rfind('/')
 
109
    if idx != -1:
 
110
        name = name[idx+1 : ]
 
111
    idx = name.rfind('\\')
 
112
    if idx != -1:
 
113
        name = name[idx+1 : ]
 
114
 
 
115
    # make it not a hidden file
 
116
    name = name.lstrip('.')
 
117
 
 
118
    # remove any wierd characters; we don't escape them but rather
 
119
    # just pull them out
 
120
    name = re.sub(r'[^\w.]', '', name)
 
121
 
 
122
    s = hexlify(rand_bytes(8))
 
123
    return '-'.join((name, compact_date(time()), s))
157
124
 
158
125
 
159
126
def gen_root_id():
162
129
 
163
130
 
164
131
class TreeEntry(object):
165
 
    """An entry that implements the minimum interface used by commands.
 
132
    """An entry that implements the minium interface used by commands.
166
133
 
167
134
    This needs further inspection, it may be better to have 
168
135
    InventoryEntries without ids - though that seems wrong. For now,
216
183
        return ''
217
184
 
218
185
 
219
 
class WorkingTree(bzrlib.mutabletree.MutableTree):
 
186
class WorkingTree(bzrlib.tree.Tree):
220
187
    """Working copy tree.
221
188
 
222
189
    The inventory is held in the `Branch` working-inventory, and the
244
211
        self.bzrdir = _bzrdir
245
212
        if not _internal:
246
213
            # not created via open etc.
247
 
            warnings.warn("WorkingTree() is deprecated as of bzr version 0.8. "
 
214
            warn("WorkingTree() is deprecated as of bzr version 0.8. "
248
215
                 "Please use bzrdir.open_workingtree or WorkingTree.open().",
249
216
                 DeprecationWarning,
250
217
                 stacklevel=2)
251
218
            wt = WorkingTree.open(basedir)
252
 
            self._branch = wt.branch
 
219
            self.branch = wt.branch
253
220
            self.basedir = wt.basedir
254
221
            self._control_files = wt._control_files
255
222
            self._hashcache = wt._hashcache
264
231
        mutter("opening working tree %r", basedir)
265
232
        if deprecated_passed(branch):
266
233
            if not _internal:
267
 
                warnings.warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
268
 
                     " Please use bzrdir.open_workingtree() or"
269
 
                     " WorkingTree.open().",
 
234
                warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
 
235
                     " Please use bzrdir.open_workingtree() or WorkingTree.open().",
270
236
                     DeprecationWarning,
271
237
                     stacklevel=2
272
238
                     )
273
 
            self._branch = branch
 
239
            self.branch = branch
274
240
        else:
275
 
            self._branch = self.bzrdir.open_branch()
 
241
            self.branch = self.bzrdir.open_branch()
 
242
        assert isinstance(self.branch, Branch), \
 
243
            "branch %r is not a Branch" % self.branch
276
244
        self.basedir = realpath(basedir)
277
245
        # if branch is at our basedir and is a format 6 or less
278
246
        if isinstance(self._format, WorkingTreeFormat2):
279
247
            # share control object
280
248
            self._control_files = self.branch.control_files
 
249
        elif _control_files is not None:
 
250
            assert False, "not done yet"
 
251
#            self._control_files = _control_files
281
252
        else:
282
 
            # assume all other formats have their own control files.
283
 
            assert isinstance(_control_files, LockableFiles), \
284
 
                    "_control_files must be a LockableFiles, not %r" \
285
 
                    % _control_files
286
 
            self._control_files = _control_files
 
253
            # only ready for format 3
 
254
            assert isinstance(self._format, WorkingTreeFormat3)
 
255
            self._control_files = LockableFiles(
 
256
                self.bzrdir.get_workingtree_transport(None),
 
257
                'lock')
 
258
 
287
259
        # update the whole cache up front and write to disk if anything changed;
288
260
        # in the future we might want to do this more selectively
289
261
        # two possible ways offer themselves : in self._unlock, write the cache
290
262
        # if needed, or, when the cache sees a change, append it to the hash
291
263
        # cache file, and have the parser take the most recent entry for a
292
264
        # given path only.
293
 
        cache_filename = self.bzrdir.get_workingtree_transport(None).local_abspath('stat-cache')
 
265
        cache_filename = self.bzrdir.get_workingtree_transport(None).abspath('stat-cache')
294
266
        hc = self._hashcache = HashCache(basedir, cache_filename, self._control_files._file_mode)
295
267
        hc.read()
296
268
        # is this scan needed ? it makes things kinda slow.
297
 
        #hc.scan()
 
269
        hc.scan()
298
270
 
299
271
        if hc.needs_write:
300
272
            mutter("write hc")
305
277
        else:
306
278
            self._set_inventory(_inventory)
307
279
 
308
 
    branch = property(
309
 
        fget=lambda self: self._branch,
310
 
        doc="""The branch this WorkingTree is connected to.
311
 
 
312
 
            This cannot be set - it is reflective of the actual disk structure
313
 
            the working tree has been constructed from.
314
 
            """)
315
 
 
316
 
    def break_lock(self):
317
 
        """Break a lock if one is present from another instance.
318
 
 
319
 
        Uses the ui factory to ask for confirmation if the lock may be from
320
 
        an active process.
321
 
 
322
 
        This will probe the repository for its lock as well.
323
 
        """
324
 
        self._control_files.break_lock()
325
 
        self.branch.break_lock()
326
 
 
327
280
    def _set_inventory(self, inv):
328
 
        assert inv.root is not None
329
281
        self._inventory = inv
 
282
        self.path2id = self._inventory.path2id
 
283
 
 
284
    def is_control_filename(self, filename):
 
285
        """True if filename is the name of a control file in this tree.
 
286
        
 
287
        This is true IF and ONLY IF the filename is part of the meta data
 
288
        that bzr controls in this tree. I.E. a random .bzr directory placed
 
289
        on disk will not be a control file for this tree.
 
290
        """
 
291
        try:
 
292
            self.bzrdir.transport.relpath(self.abspath(filename))
 
293
            return True
 
294
        except errors.PathNotChild:
 
295
            return False
330
296
 
331
297
    @staticmethod
332
298
    def open(path=None, _unsupported=False):
348
314
        run into /.  If there isn't one, raises NotBranchError.
349
315
        TODO: give this a new exception.
350
316
        If there is one, it is returned, along with the unused portion of path.
351
 
 
352
 
        :return: The WorkingTree that contains 'path', and the rest of path
353
317
        """
354
318
        if path is None:
355
 
            path = osutils.getcwd()
 
319
            path = os.getcwdu()
356
320
        control, relpath = bzrdir.BzrDir.open_containing(path)
357
 
 
358
321
        return control.open_workingtree(), relpath
359
322
 
360
323
    @staticmethod
373
336
        """
374
337
        inv = self._inventory
375
338
        for path, ie in inv.iter_entries():
376
 
            if osutils.lexists(self.abspath(path)):
 
339
            if bzrlib.osutils.lexists(self.abspath(path)):
377
340
                yield ie.file_id
378
341
 
379
342
    def __repr__(self):
384
347
        return pathjoin(self.basedir, filename)
385
348
    
386
349
    def basis_tree(self):
387
 
        """Return RevisionTree for the current last revision.
388
 
        
389
 
        If the left most parent is a ghost then the returned tree will be an
390
 
        empty tree - one obtained by calling repository.revision_tree(None).
391
 
        """
392
 
        try:
393
 
            revision_id = self.get_parent_ids()[0]
394
 
        except IndexError:
395
 
            # no parents, return an empty revision tree.
396
 
            # in the future this should return the tree for
397
 
            # 'empty:' - the implicit root empty tree.
398
 
            return self.branch.repository.revision_tree(None)
399
 
        else:
 
350
        """Return RevisionTree for the current last revision."""
 
351
        revision_id = self.last_revision()
 
352
        if revision_id is not None:
400
353
            try:
401
 
                xml = self.read_basis_inventory()
402
 
                inv = bzrlib.xml6.serializer_v6.read_inventory_from_string(xml)
403
 
                if inv is not None and inv.revision_id == revision_id:
404
 
                    return bzrlib.tree.RevisionTree(self.branch.repository, 
405
 
                                                    inv, revision_id)
406
 
            except (NoSuchFile, errors.BadInventoryFormat):
 
354
                xml = self.read_basis_inventory(revision_id)
 
355
                inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
356
                return bzrlib.tree.RevisionTree(self.branch.repository, inv,
 
357
                                                revision_id)
 
358
            except NoSuchFile:
407
359
                pass
408
 
        # No cached copy available, retrieve from the repository.
409
 
        # FIXME? RBC 20060403 should we cache the inventory locally
410
 
        # at this point ?
411
 
        try:
412
 
            return self.branch.repository.revision_tree(revision_id)
413
 
        except errors.RevisionNotPresent:
414
 
            # the basis tree *may* be a ghost or a low level error may have
415
 
            # occured. If the revision is present, its a problem, if its not
416
 
            # its a ghost.
417
 
            if self.branch.repository.has_revision(revision_id):
418
 
                raise
419
 
            # the basis tree is a ghost so return an empty tree.
420
 
            return self.branch.repository.revision_tree(None)
 
360
        return self.branch.repository.revision_tree(revision_id)
421
361
 
422
362
    @staticmethod
423
363
    @deprecated_method(zero_eight)
436
376
        XXX: When BzrDir is present, these should be created through that 
437
377
        interface instead.
438
378
        """
439
 
        warnings.warn('delete WorkingTree.create', stacklevel=3)
 
379
        warn('delete WorkingTree.create', stacklevel=3)
440
380
        transport = get_transport(directory)
441
381
        if branch.bzrdir.root_transport.base == transport.base:
442
382
            # same dir 
457
397
        """
458
398
        return bzrdir.BzrDir.create_standalone_workingtree(directory)
459
399
 
460
 
    def relpath(self, path):
461
 
        """Return the local path portion from a given path.
462
 
        
463
 
        The path may be absolute or relative. If its a relative path it is 
464
 
        interpreted relative to the python current working directory.
465
 
        """
466
 
        return relpath(self.basedir, path)
 
400
    def relpath(self, abs):
 
401
        """Return the local path portion from a given absolute path."""
 
402
        return relpath(self.basedir, abs)
467
403
 
468
404
    def has_filename(self, filename):
469
 
        return osutils.lexists(self.abspath(filename))
 
405
        return bzrlib.osutils.lexists(self.abspath(filename))
470
406
 
471
407
    def get_file(self, file_id):
472
408
        return self.get_file_byname(self.id2path(file_id))
473
409
 
474
 
    def get_file_text(self, file_id):
475
 
        return self.get_file(file_id).read()
476
 
 
477
410
    def get_file_byname(self, filename):
478
411
        return file(self.abspath(filename), 'rb')
479
412
 
480
 
    def get_parent_ids(self):
481
 
        """See Tree.get_parent_ids.
482
 
        
483
 
        This implementation reads the pending merges list and last_revision
484
 
        value and uses that to decide what the parents list should be.
485
 
        """
486
 
        last_rev = self._last_revision()
487
 
        if last_rev is None:
488
 
            parents = []
489
 
        else:
490
 
            parents = [last_rev]
491
 
        try:
492
 
            merges_file = self._control_files.get_utf8('pending-merges')
493
 
        except NoSuchFile:
494
 
            pass
495
 
        else:
496
 
            for l in merges_file.readlines():
497
 
                parents.append(l.rstrip('\n'))
498
 
        return parents
499
 
 
500
413
    def get_root_id(self):
501
414
        """Return the id of this trees root"""
502
415
        inv = self.read_working_inventory()
535
448
        if revision_id is None:
536
449
            transform_tree(tree, self)
537
450
        else:
538
 
            # TODO now merge from tree.last_revision to revision (to preserve
539
 
            # user local changes)
 
451
            # TODO now merge from tree.last_revision to revision
540
452
            transform_tree(tree, self)
541
 
            tree.set_parent_ids([revision_id])
 
453
            tree.set_last_revision(revision_id)
 
454
 
 
455
    @needs_write_lock
 
456
    def commit(self, *args, **kwargs):
 
457
        from bzrlib.commit import Commit
 
458
        # args for wt.commit start at message from the Commit.commit method,
 
459
        # but with branch a kwarg now, passing in args as is results in the
 
460
        #message being used for the branch
 
461
        args = (DEPRECATED_PARAMETER, ) + args
 
462
        Commit().commit(working_tree=self, *args, **kwargs)
 
463
        self._set_inventory(self.read_working_inventory())
542
464
 
543
465
    def id2abspath(self, file_id):
544
466
        return self.abspath(self.id2path(file_id))
549
471
        if not inv.has_id(file_id):
550
472
            return False
551
473
        path = inv.id2path(file_id)
552
 
        return osutils.lexists(self.abspath(path))
 
474
        return bzrlib.osutils.lexists(self.abspath(path))
553
475
 
554
476
    def has_or_had_id(self, file_id):
555
477
        if file_id == self.inventory.root.file_id:
562
484
        return os.path.getsize(self.id2abspath(file_id))
563
485
 
564
486
    @needs_read_lock
565
 
    def get_file_sha1(self, file_id, path=None):
566
 
        if not path:
567
 
            path = self._inventory.id2path(file_id)
 
487
    def get_file_sha1(self, file_id):
 
488
        path = self._inventory.id2path(file_id)
568
489
        return self._hashcache.get_sha1(path)
569
490
 
570
 
    def get_file_mtime(self, file_id, path=None):
571
 
        if not path:
572
 
            path = self._inventory.id2path(file_id)
573
 
        return os.lstat(self.abspath(path)).st_mtime
574
 
 
575
 
    if not supports_executable():
576
 
        def is_executable(self, file_id, path=None):
 
491
    def is_executable(self, file_id):
 
492
        if not supports_executable():
577
493
            return self._inventory[file_id].executable
578
 
    else:
579
 
        def is_executable(self, file_id, path=None):
580
 
            if not path:
581
 
                path = self._inventory.id2path(file_id)
 
494
        else:
 
495
            path = self._inventory.id2path(file_id)
582
496
            mode = os.lstat(self.abspath(path)).st_mode
583
 
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
497
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC&mode)
584
498
 
585
499
    @needs_write_lock
586
 
    def _add(self, files, ids, kinds):
587
 
        """See MutableTree._add."""
 
500
    def add(self, files, ids=None):
 
501
        """Make files versioned.
 
502
 
 
503
        Note that the command line normally calls smart_add instead,
 
504
        which can automatically recurse.
 
505
 
 
506
        This adds the files to the inventory, so that they will be
 
507
        recorded by the next commit.
 
508
 
 
509
        files
 
510
            List of paths to add, relative to the base of the tree.
 
511
 
 
512
        ids
 
513
            If set, use these instead of automatically generated ids.
 
514
            Must be the same length as the list of files, but may
 
515
            contain None for ids that are to be autogenerated.
 
516
 
 
517
        TODO: Perhaps have an option to add the ids even if the files do
 
518
              not (yet) exist.
 
519
 
 
520
        TODO: Perhaps callback with the ids and paths as they're added.
 
521
        """
588
522
        # TODO: Re-adding a file that is removed in the working copy
589
523
        # should probably put it back with the previous ID.
590
 
        # the read and write working inventory should not occur in this 
591
 
        # function - they should be part of lock_write and unlock.
 
524
        if isinstance(files, basestring):
 
525
            assert(ids is None or isinstance(ids, basestring))
 
526
            files = [files]
 
527
            if ids is not None:
 
528
                ids = [ids]
 
529
 
 
530
        if ids is None:
 
531
            ids = [None] * len(files)
 
532
        else:
 
533
            assert(len(ids) == len(files))
 
534
 
592
535
        inv = self.read_working_inventory()
593
 
        for f, file_id, kind in zip(files, ids, kinds):
594
 
            assert kind is not None
 
536
        for f,file_id in zip(files, ids):
 
537
            if self.is_control_filename(f):
 
538
                raise BzrError("cannot add control file %s" % quotefn(f))
 
539
 
 
540
            fp = splitpath(f)
 
541
 
 
542
            if len(fp) == 0:
 
543
                raise BzrError("cannot add top-level %r" % f)
 
544
 
 
545
            fullpath = normpath(self.abspath(f))
 
546
 
 
547
            try:
 
548
                kind = file_kind(fullpath)
 
549
            except OSError, e:
 
550
                if e.errno == errno.ENOENT:
 
551
                    raise NoSuchFile(fullpath)
 
552
                # maybe something better?
 
553
                raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
 
554
 
 
555
            if not InventoryEntry.versionable_kind(kind):
 
556
                raise BzrError('cannot add: not a versionable file ('
 
557
                               'i.e. regular file, symlink or directory): %s' % quotefn(f))
 
558
 
595
559
            if file_id is None:
596
 
                inv.add_path(f, kind=kind)
597
 
            else:
598
 
                inv.add_path(f, kind=kind, file_id=file_id)
 
560
                file_id = gen_file_id(f)
 
561
            inv.add_path(f, kind=kind, file_id=file_id)
 
562
 
 
563
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
599
564
        self._write_inventory(inv)
600
565
 
601
 
    @needs_tree_write_lock
602
 
    def _gather_kinds(self, files, kinds):
603
 
        """See MutableTree._gather_kinds."""
604
 
        for pos, f in enumerate(files):
605
 
            if kinds[pos] is None:
606
 
                fullpath = normpath(self.abspath(f))
607
 
                try:
608
 
                    kinds[pos] = file_kind(fullpath)
609
 
                except OSError, e:
610
 
                    if e.errno == errno.ENOENT:
611
 
                        raise NoSuchFile(fullpath)
612
 
 
613
566
    @needs_write_lock
614
 
    def add_parent_tree_id(self, revision_id, allow_leftmost_as_ghost=False):
615
 
        """Add revision_id as a parent.
616
 
 
617
 
        This is equivalent to retrieving the current list of parent ids
618
 
        and setting the list to its value plus revision_id.
619
 
 
620
 
        :param revision_id: The revision id to add to the parent list. It may
621
 
        be a ghost revision as long as its not the first parent to be added,
622
 
        or the allow_leftmost_as_ghost parameter is set True.
623
 
        :param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
624
 
        """
625
 
        parents = self.get_parent_ids() + [revision_id]
626
 
        self.set_parent_ids(parents,
627
 
            allow_leftmost_as_ghost=len(parents) > 1 or allow_leftmost_as_ghost)
628
 
 
629
 
    @needs_tree_write_lock
630
 
    def add_parent_tree(self, parent_tuple, allow_leftmost_as_ghost=False):
631
 
        """Add revision_id, tree tuple as a parent.
632
 
 
633
 
        This is equivalent to retrieving the current list of parent trees
634
 
        and setting the list to its value plus parent_tuple. See also
635
 
        add_parent_tree_id - if you only have a parent id available it will be
636
 
        simpler to use that api. If you have the parent already available, using
637
 
        this api is preferred.
638
 
 
639
 
        :param parent_tuple: The (revision id, tree) to add to the parent list.
640
 
            If the revision_id is a ghost, pass None for the tree.
641
 
        :param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
642
 
        """
643
 
        parent_ids = self.get_parent_ids() + [parent_tuple[0]]
644
 
        if len(parent_ids) > 1:
645
 
            # the leftmost may have already been a ghost, preserve that if it
646
 
            # was.
647
 
            allow_leftmost_as_ghost = True
648
 
        self.set_parent_ids(parent_ids,
649
 
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
650
 
 
651
 
    @needs_tree_write_lock
652
567
    def add_pending_merge(self, *revision_ids):
653
568
        # TODO: Perhaps should check at this point that the
654
569
        # history of the revision is actually present?
655
 
        parents = self.get_parent_ids()
 
570
        p = self.pending_merges()
656
571
        updated = False
657
572
        for rev_id in revision_ids:
658
 
            if rev_id in parents:
 
573
            if rev_id in p:
659
574
                continue
660
 
            parents.append(rev_id)
 
575
            p.append(rev_id)
661
576
            updated = True
662
577
        if updated:
663
 
            self.set_parent_ids(parents, allow_leftmost_as_ghost=True)
 
578
            self.set_pending_merges(p)
664
579
 
665
 
    @deprecated_method(zero_eleven)
666
580
    @needs_read_lock
667
581
    def pending_merges(self):
668
582
        """Return a list of pending merges.
669
583
 
670
584
        These are revisions that have been merged into the working
671
585
        directory but not yet committed.
672
 
 
673
 
        As of 0.11 this is deprecated. Please see WorkingTree.get_parent_ids()
674
 
        instead - which is available on all tree objects.
675
 
        """
676
 
        return self.get_parent_ids()[1:]
677
 
 
678
 
    @needs_tree_write_lock
679
 
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
680
 
        """Set the parent ids to revision_ids.
681
 
        
682
 
        See also set_parent_trees. This api will try to retrieve the tree data
683
 
        for each element of revision_ids from the trees repository. If you have
684
 
        tree data already available, it is more efficient to use
685
 
        set_parent_trees rather than set_parent_ids. set_parent_ids is however
686
 
        an easier API to use.
687
 
 
688
 
        :param revision_ids: The revision_ids to set as the parent ids of this
689
 
            working tree. Any of these may be ghosts.
690
 
        """
691
 
        if len(revision_ids) > 0:
692
 
            leftmost_id = revision_ids[0]
693
 
            if (not allow_leftmost_as_ghost and not
694
 
                self.branch.repository.has_revision(leftmost_id)):
695
 
                raise errors.GhostRevisionUnusableHere(leftmost_id)
696
 
            self.set_last_revision(leftmost_id)
697
 
        else:
698
 
            self.set_last_revision(None)
699
 
        merges = revision_ids[1:]
700
 
        self._control_files.put_utf8('pending-merges', '\n'.join(merges))
701
 
 
702
 
    @needs_tree_write_lock
703
 
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
704
 
        """See MutableTree.set_parent_trees."""
705
 
        # parent trees are not used in current format trees, delegate to
706
 
        # set_parent_ids
707
 
        self.set_parent_ids([rev for (rev, tree) in parents_list],
708
 
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
709
 
 
710
 
    @needs_tree_write_lock
 
586
        """
 
587
        try:
 
588
            merges_file = self._control_files.get_utf8('pending-merges')
 
589
        except OSError, e:
 
590
            if e.errno != errno.ENOENT:
 
591
                raise
 
592
            return []
 
593
        p = []
 
594
        for l in merges_file.readlines():
 
595
            p.append(l.rstrip('\n'))
 
596
        return p
 
597
 
 
598
    @needs_write_lock
711
599
    def set_pending_merges(self, rev_list):
712
 
        parents = self.get_parent_ids()
713
 
        leftmost = parents[:1]
714
 
        new_parents = leftmost + rev_list
715
 
        self.set_parent_ids(new_parents)
716
 
 
717
 
    @needs_tree_write_lock
718
 
    def set_merge_modified(self, modified_hashes):
719
 
        def iter_stanzas():
720
 
            for file_id, hash in modified_hashes.iteritems():
721
 
                yield Stanza(file_id=file_id, hash=hash)
722
 
        self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
723
 
 
724
 
    @needs_tree_write_lock
725
 
    def _put_rio(self, filename, stanzas, header):
726
 
        my_file = rio_file(stanzas, header)
727
 
        self._control_files.put(filename, my_file)
728
 
 
729
 
    @needs_write_lock # because merge pulls data into the branch.
730
 
    def merge_from_branch(self, branch, to_revision=None):
731
 
        """Merge from a branch into this working tree.
732
 
 
733
 
        :param branch: The branch to merge from.
734
 
        :param to_revision: If non-None, the merge will merge to to_revision, but 
735
 
            not beyond it. to_revision does not need to be in the history of
736
 
            the branch when it is supplied. If None, to_revision defaults to
737
 
            branch.last_revision().
738
 
        """
739
 
        from bzrlib.merge import Merger, Merge3Merger
740
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
741
 
        try:
742
 
            merger = Merger(self.branch, this_tree=self, pb=pb)
743
 
            merger.pp = ProgressPhase("Merge phase", 5, pb)
744
 
            merger.pp.next_phase()
745
 
            # check that there are no
746
 
            # local alterations
747
 
            merger.check_basis(check_clean=True, require_commits=False)
748
 
            if to_revision is None:
749
 
                to_revision = branch.last_revision()
750
 
            merger.other_rev_id = to_revision
751
 
            if merger.other_rev_id is None:
752
 
                raise error.NoCommits(branch)
753
 
            self.branch.fetch(branch, last_revision=merger.other_rev_id)
754
 
            merger.other_basis = merger.other_rev_id
755
 
            merger.other_tree = self.branch.repository.revision_tree(
756
 
                merger.other_rev_id)
757
 
            merger.pp.next_phase()
758
 
            merger.find_base()
759
 
            if merger.base_rev_id == merger.other_rev_id:
760
 
                raise errors.PointlessMerge
761
 
            merger.backup_files = False
762
 
            merger.merge_type = Merge3Merger
763
 
            merger.set_interesting_files(None)
764
 
            merger.show_base = False
765
 
            merger.reprocess = False
766
 
            conflicts = merger.do_merge()
767
 
            merger.set_pending()
768
 
        finally:
769
 
            pb.finished()
770
 
        return conflicts
771
 
 
772
 
    @needs_read_lock
773
 
    def merge_modified(self):
774
 
        try:
775
 
            hashfile = self._control_files.get('merge-hashes')
776
 
        except NoSuchFile:
777
 
            return {}
778
 
        merge_hashes = {}
779
 
        try:
780
 
            if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
781
 
                raise MergeModifiedFormatError()
782
 
        except StopIteration:
783
 
            raise MergeModifiedFormatError()
784
 
        for s in RioReader(hashfile):
785
 
            file_id = s.get("file_id")
786
 
            if file_id not in self.inventory:
787
 
                continue
788
 
            hash = s.get("hash")
789
 
            if hash == self.get_file_sha1(file_id):
790
 
                merge_hashes[file_id] = hash
791
 
        return merge_hashes
792
 
 
793
 
    @needs_write_lock
794
 
    def mkdir(self, path, file_id=None):
795
 
        """See MutableTree.mkdir()."""
796
 
        if file_id is None:
797
 
            file_id = gen_file_id(os.path.basename(path))
798
 
        os.mkdir(self.abspath(path))
799
 
        self.add(path, file_id, 'directory')
800
 
        return file_id
 
600
        self._control_files.put_utf8('pending-merges', '\n'.join(rev_list))
801
601
 
802
602
    def get_symlink_target(self, file_id):
803
603
        return os.readlink(self.id2abspath(file_id))
811
611
            return '?'
812
612
 
813
613
    def list_files(self):
814
 
        """Recursively list all files as (path, class, kind, id, entry).
 
614
        """Recursively list all files as (path, class, kind, id).
815
615
 
816
616
        Lists, but does not descend into unversioned directories.
817
617
 
821
621
        Skips the control directory.
822
622
        """
823
623
        inv = self._inventory
824
 
        # Convert these into local objects to save lookup times
825
 
        pathjoin = osutils.pathjoin
826
 
        file_kind = osutils.file_kind
827
 
 
828
 
        # transport.base ends in a slash, we want the piece
829
 
        # between the last two slashes
830
 
        transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
831
 
 
832
 
        fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
833
 
 
834
 
        # directory file_id, relative path, absolute path, reverse sorted children
835
 
        children = os.listdir(self.basedir)
836
 
        children.sort()
837
 
        # jam 20060527 The kernel sized tree seems equivalent whether we 
838
 
        # use a deque and popleft to keep them sorted, or if we use a plain
839
 
        # list and just reverse() them.
840
 
        children = collections.deque(children)
841
 
        stack = [(inv.root.file_id, u'', self.basedir, children)]
842
 
        while stack:
843
 
            from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
844
 
 
845
 
            while children:
846
 
                f = children.popleft()
 
624
 
 
625
        def descend(from_dir_relpath, from_dir_id, dp):
 
626
            ls = os.listdir(dp)
 
627
            ls.sort()
 
628
            for f in ls:
847
629
                ## TODO: If we find a subdirectory with its own .bzr
848
630
                ## directory, then that is a separate tree and we
849
631
                ## should exclude it.
850
632
 
851
633
                # the bzrdir for this tree
852
 
                if transport_base_dir == f:
 
634
                if self.bzrdir.transport.base.endswith(f + '/'):
853
635
                    continue
854
636
 
855
 
                # we know that from_dir_relpath and from_dir_abspath never end in a slash
856
 
                # and 'f' doesn't begin with one, we can do a string op, rather
857
 
                # than the checks of pathjoin(), all relative paths will have an extra slash
858
 
                # at the beginning
859
 
                fp = from_dir_relpath + '/' + f
 
637
                # path within tree
 
638
                fp = appendpath(from_dir_relpath, f)
860
639
 
861
640
                # absolute path
862
 
                fap = from_dir_abspath + '/' + f
 
641
                fap = appendpath(dp, f)
863
642
                
864
643
                f_ie = inv.get_child(from_dir_id, f)
865
644
                if f_ie:
866
645
                    c = 'V'
867
 
                elif self.is_ignored(fp[1:]):
 
646
                elif self.is_ignored(fp):
868
647
                    c = 'I'
869
648
                else:
870
 
                    # we may not have found this file, because of a unicode issue
871
 
                    f_norm, can_access = osutils.normalized_filename(f)
872
 
                    if f == f_norm or not can_access:
873
 
                        # No change, so treat this file normally
874
 
                        c = '?'
875
 
                    else:
876
 
                        # this file can be accessed by a normalized path
877
 
                        # check again if it is versioned
878
 
                        # these lines are repeated here for performance
879
 
                        f = f_norm
880
 
                        fp = from_dir_relpath + '/' + f
881
 
                        fap = from_dir_abspath + '/' + f
882
 
                        f_ie = inv.get_child(from_dir_id, f)
883
 
                        if f_ie:
884
 
                            c = 'V'
885
 
                        elif self.is_ignored(fp[1:]):
886
 
                            c = 'I'
887
 
                        else:
888
 
                            c = '?'
 
649
                    c = '?'
889
650
 
890
651
                fk = file_kind(fap)
891
652
 
897
658
 
898
659
                # make a last minute entry
899
660
                if f_ie:
900
 
                    yield fp[1:], c, fk, f_ie.file_id, f_ie
 
661
                    entry = f_ie
901
662
                else:
902
 
                    try:
903
 
                        yield fp[1:], c, fk, None, fk_entries[fk]()
904
 
                    except KeyError:
905
 
                        yield fp[1:], c, fk, None, TreeEntry()
906
 
                    continue
 
663
                    if fk == 'directory':
 
664
                        entry = TreeDirectory()
 
665
                    elif fk == 'file':
 
666
                        entry = TreeFile()
 
667
                    elif fk == 'symlink':
 
668
                        entry = TreeLink()
 
669
                    else:
 
670
                        entry = TreeEntry()
907
671
                
 
672
                yield fp, c, fk, (f_ie and f_ie.file_id), entry
 
673
 
908
674
                if fk != 'directory':
909
675
                    continue
910
676
 
911
 
                # But do this child first
912
 
                new_children = os.listdir(fap)
913
 
                new_children.sort()
914
 
                new_children = collections.deque(new_children)
915
 
                stack.append((f_ie.file_id, fp, fap, new_children))
916
 
                # Break out of inner loop, so that we start outer loop with child
917
 
                break
918
 
            else:
919
 
                # if we finished all children, pop it off the stack
920
 
                stack.pop()
921
 
 
922
 
    @needs_tree_write_lock
 
677
                if c != 'V':
 
678
                    # don't descend unversioned directories
 
679
                    continue
 
680
                
 
681
                for ff in descend(fp, f_ie.file_id, fap):
 
682
                    yield ff
 
683
 
 
684
        for f in descend(u'', inv.root.file_id, self.basedir):
 
685
            yield f
 
686
 
 
687
    @needs_write_lock
923
688
    def move(self, from_paths, to_name):
924
689
        """Rename files.
925
690
 
944
709
        if not self.has_filename(to_name):
945
710
            raise BzrError("destination %r not in working directory" % to_abs)
946
711
        to_dir_id = inv.path2id(to_name)
947
 
        if to_dir_id is None and to_name != '':
 
712
        if to_dir_id == None and to_name != '':
948
713
            raise BzrError("destination %r is not a versioned directory" % to_name)
949
714
        to_dir_ie = inv[to_dir_id]
950
 
        if to_dir_ie.kind != 'directory':
 
715
        if to_dir_ie.kind not in ('directory', 'root_directory'):
951
716
            raise BzrError("destination %r is not a directory" % to_abs)
952
717
 
953
718
        to_idpath = inv.get_idpath(to_dir_id)
956
721
            if not self.has_filename(f):
957
722
                raise BzrError("%r does not exist in working tree" % f)
958
723
            f_id = inv.path2id(f)
959
 
            if f_id is None:
 
724
            if f_id == None:
960
725
                raise BzrError("%r is not versioned" % f)
961
726
            name_tail = splitpath(f)[-1]
962
 
            dest_path = pathjoin(to_name, name_tail)
 
727
            dest_path = appendpath(to_name, name_tail)
963
728
            if self.has_filename(dest_path):
964
729
                raise BzrError("destination %r already exists" % dest_path)
965
730
            if f_id in to_idpath:
972
737
        try:
973
738
            for f in from_paths:
974
739
                name_tail = splitpath(f)[-1]
975
 
                dest_path = pathjoin(to_name, name_tail)
 
740
                dest_path = appendpath(to_name, name_tail)
976
741
                result.append((f, dest_path))
977
742
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
978
743
                try:
988
753
        self._write_inventory(inv)
989
754
        return result
990
755
 
991
 
    @needs_tree_write_lock
 
756
    @needs_write_lock
992
757
    def rename_one(self, from_rel, to_rel):
993
758
        """Rename one file.
994
759
 
1001
766
            raise BzrError("can't rename: new working file %r already exists" % to_rel)
1002
767
 
1003
768
        file_id = inv.path2id(from_rel)
1004
 
        if file_id is None:
 
769
        if file_id == None:
1005
770
            raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1006
771
 
1007
772
        entry = inv[file_id]
1013
778
 
1014
779
        to_dir, to_tail = os.path.split(to_rel)
1015
780
        to_dir_id = inv.path2id(to_dir)
1016
 
        if to_dir_id is None and to_dir != '':
 
781
        if to_dir_id == None and to_dir != '':
1017
782
            raise BzrError("can't determine destination directory id for %r" % to_dir)
1018
783
 
1019
784
        mutter("rename_one:")
1042
807
 
1043
808
        These are files in the working directory that are not versioned or
1044
809
        control files or ignored.
 
810
        
 
811
        >>> from bzrlib.bzrdir import ScratchDir
 
812
        >>> d = ScratchDir(files=['foo', 'foo~'])
 
813
        >>> b = d.open_branch()
 
814
        >>> tree = d.open_workingtree()
 
815
        >>> map(str, tree.unknowns())
 
816
        ['foo']
 
817
        >>> tree.add('foo')
 
818
        >>> list(b.unknowns())
 
819
        []
 
820
        >>> tree.remove('foo')
 
821
        >>> list(b.unknowns())
 
822
        [u'foo']
1045
823
        """
1046
824
        for subp in self.extras():
1047
825
            if not self.is_ignored(subp):
1048
826
                yield subp
1049
 
    
1050
 
    @needs_tree_write_lock
1051
 
    def unversion(self, file_ids):
1052
 
        """Remove the file ids in file_ids from the current versioned set.
1053
 
 
1054
 
        When a file_id is unversioned, all of its children are automatically
1055
 
        unversioned.
1056
 
 
1057
 
        :param file_ids: The file ids to stop versioning.
1058
 
        :raises: NoSuchId if any fileid is not currently versioned.
1059
 
        """
1060
 
        for file_id in file_ids:
1061
 
            if self._inventory.has_id(file_id):
1062
 
                self._inventory.remove_recursive_id(file_id)
1063
 
            else:
1064
 
                raise errors.NoSuchId(self, file_id)
1065
 
        if len(file_ids):
1066
 
            # in the future this should just set a dirty bit to wait for the 
1067
 
            # final unlock. However, until all methods of workingtree start
1068
 
            # with the current in -memory inventory rather than triggering 
1069
 
            # a read, it is more complex - we need to teach read_inventory
1070
 
            # to know when to read, and when to not read first... and possibly
1071
 
            # to save first when the in memory one may be corrupted.
1072
 
            # so for now, we just only write it if it is indeed dirty.
1073
 
            # - RBC 20060907
1074
 
            self._write_inventory(self._inventory)
1075
 
    
1076
 
    @deprecated_method(zero_eight)
 
827
 
1077
828
    def iter_conflicts(self):
1078
 
        """List all files in the tree that have text or content conflicts.
1079
 
        DEPRECATED.  Use conflicts instead."""
1080
 
        return self._iter_conflicts()
1081
 
 
1082
 
    def _iter_conflicts(self):
1083
829
        conflicted = set()
1084
 
        for info in self.list_files():
1085
 
            path = info[0]
 
830
        for path in (s[0] for s in self.list_files()):
1086
831
            stem = get_conflicted_stem(path)
1087
832
            if stem is None:
1088
833
                continue
1092
837
 
1093
838
    @needs_write_lock
1094
839
    def pull(self, source, overwrite=False, stop_revision=None):
1095
 
        top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1096
840
        source.lock_read()
1097
841
        try:
1098
 
            pp = ProgressPhase("Pull phase", 2, top_pb)
1099
 
            pp.next_phase()
1100
842
            old_revision_history = self.branch.revision_history()
1101
843
            basis_tree = self.basis_tree()
1102
844
            count = self.branch.pull(source, overwrite, stop_revision)
1103
845
            new_revision_history = self.branch.revision_history()
1104
846
            if new_revision_history != old_revision_history:
1105
 
                pp.next_phase()
1106
847
                if len(old_revision_history):
1107
848
                    other_revision = old_revision_history[-1]
1108
849
                else:
1109
850
                    other_revision = None
1110
851
                repository = self.branch.repository
1111
 
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
1112
 
                try:
1113
 
                    new_basis_tree = self.branch.basis_tree()
1114
 
                    merge_inner(self.branch,
1115
 
                                new_basis_tree,
1116
 
                                basis_tree,
1117
 
                                this_tree=self,
1118
 
                                pb=pb)
1119
 
                finally:
1120
 
                    pb.finished()
1121
 
                # TODO - dedup parents list with things merged by pull ?
1122
 
                # reuse the revisiontree we merged against to set the new
1123
 
                # tree data.
1124
 
                parent_trees = [(self.branch.last_revision(), new_basis_tree)]
1125
 
                # we have to pull the merge trees out again, because 
1126
 
                # merge_inner has set the ids. - this corner is not yet 
1127
 
                # layered well enough to prevent double handling.
1128
 
                merges = self.get_parent_ids()[1:]
1129
 
                parent_trees.extend([
1130
 
                    (parent, repository.revision_tree(parent)) for
1131
 
                     parent in merges])
1132
 
                self.set_parent_trees(parent_trees)
 
852
                merge_inner(self.branch,
 
853
                            self.branch.basis_tree(),
 
854
                            basis_tree, 
 
855
                            this_tree=self, 
 
856
                            pb=bzrlib.ui.ui_factory.progress_bar())
 
857
                self.set_last_revision(self.branch.last_revision())
1133
858
            return count
1134
859
        finally:
1135
860
            source.unlock()
1136
 
            top_pb.finished()
1137
 
 
1138
 
    @needs_write_lock
1139
 
    def put_file_bytes_non_atomic(self, file_id, bytes):
1140
 
        """See MutableTree.put_file_bytes_non_atomic."""
1141
 
        stream = file(self.id2abspath(file_id), 'wb')
1142
 
        try:
1143
 
            stream.write(bytes)
1144
 
        finally:
1145
 
            stream.close()
1146
 
        # TODO: update the hashcache here ?
1147
861
 
1148
862
    def extras(self):
1149
863
        """Yield all unknown files in this WorkingTree.
1156
870
        """
1157
871
        ## TODO: Work from given directory downwards
1158
872
        for path, dir_entry in self.inventory.directories():
1159
 
            # mutter("search for unknowns in %r", path)
 
873
            mutter("search for unknowns in %r", path)
1160
874
            dirabs = self.abspath(path)
1161
875
            if not isdir(dirabs):
1162
876
                # e.g. directory deleted
1164
878
 
1165
879
            fl = []
1166
880
            for subf in os.listdir(dirabs):
1167
 
                if subf == '.bzr':
1168
 
                    continue
1169
 
                if subf not in dir_entry.children:
1170
 
                    subf_norm, can_access = osutils.normalized_filename(subf)
1171
 
                    if subf_norm != subf and can_access:
1172
 
                        if subf_norm not in dir_entry.children:
1173
 
                            fl.append(subf_norm)
1174
 
                    else:
1175
 
                        fl.append(subf)
 
881
                if (subf != '.bzr'
 
882
                    and (subf not in dir_entry.children)):
 
883
                    fl.append(subf)
1176
884
            
1177
885
            fl.sort()
1178
886
            for subf in fl:
1179
 
                subp = pathjoin(path, subf)
 
887
                subp = appendpath(path, subf)
1180
888
                yield subp
1181
889
 
1182
 
    def _translate_ignore_rule(self, rule):
1183
 
        """Translate a single ignore rule to a regex.
1184
 
 
1185
 
        There are two types of ignore rules.  Those that do not contain a / are
1186
 
        matched against the tail of the filename (that is, they do not care
1187
 
        what directory the file is in.)  Rules which do contain a slash must
1188
 
        match the entire path.  As a special case, './' at the start of the
1189
 
        string counts as a slash in the string but is removed before matching
1190
 
        (e.g. ./foo.c, ./src/foo.c)
1191
 
 
1192
 
        :return: The translated regex.
1193
 
        """
1194
 
        if rule[:2] in ('./', '.\\'):
1195
 
            # rootdir rule
1196
 
            result = fnmatch.translate(rule[2:])
1197
 
        elif '/' in rule or '\\' in rule:
1198
 
            # path prefix 
1199
 
            result = fnmatch.translate(rule)
1200
 
        else:
1201
 
            # default rule style.
1202
 
            result = "(?:.*/)?(?!.*/)" + fnmatch.translate(rule)
1203
 
        assert result[-1] == '$', "fnmatch.translate did not add the expected $"
1204
 
        return "(" + result + ")"
1205
 
 
1206
 
    def _combine_ignore_rules(self, rules):
1207
 
        """Combine a list of ignore rules into a single regex object.
1208
 
 
1209
 
        Each individual rule is combined with | to form a big regex, which then
1210
 
        has $ added to it to form something like ()|()|()$. The group index for
1211
 
        each subregex's outermost group is placed in a dictionary mapping back 
1212
 
        to the rule. This allows quick identification of the matching rule that
1213
 
        triggered a match.
1214
 
        :return: a list of the compiled regex and the matching-group index 
1215
 
        dictionaries. We return a list because python complains if you try to 
1216
 
        combine more than 100 regexes.
1217
 
        """
1218
 
        result = []
1219
 
        groups = {}
1220
 
        next_group = 0
1221
 
        translated_rules = []
1222
 
        for rule in rules:
1223
 
            translated_rule = self._translate_ignore_rule(rule)
1224
 
            compiled_rule = re.compile(translated_rule)
1225
 
            groups[next_group] = rule
1226
 
            next_group += compiled_rule.groups
1227
 
            translated_rules.append(translated_rule)
1228
 
            if next_group == 99:
1229
 
                result.append((re.compile("|".join(translated_rules)), groups))
1230
 
                groups = {}
1231
 
                next_group = 0
1232
 
                translated_rules = []
1233
 
        if len(translated_rules):
1234
 
            result.append((re.compile("|".join(translated_rules)), groups))
1235
 
        return result
1236
890
 
1237
891
    def ignored_files(self):
1238
892
        """Yield list of PATH, IGNORE_PATTERN"""
1239
893
        for subp in self.extras():
1240
894
            pat = self.is_ignored(subp)
1241
 
            if pat is not None:
 
895
            if pat != None:
1242
896
                yield subp, pat
1243
897
 
 
898
 
1244
899
    def get_ignore_list(self):
1245
900
        """Return list of ignore patterns.
1246
901
 
1247
902
        Cached in the Tree object after the first call.
1248
903
        """
1249
 
        ignoreset = getattr(self, '_ignoreset', None)
1250
 
        if ignoreset is not None:
1251
 
            return ignoreset
1252
 
 
1253
 
        ignore_globs = set(bzrlib.DEFAULT_IGNORE)
1254
 
        ignore_globs.update(ignores.get_runtime_ignores())
1255
 
 
1256
 
        ignore_globs.update(ignores.get_user_ignores())
1257
 
 
 
904
        if hasattr(self, '_ignorelist'):
 
905
            return self._ignorelist
 
906
 
 
907
        l = bzrlib.DEFAULT_IGNORE[:]
1258
908
        if self.has_filename(bzrlib.IGNORE_FILENAME):
1259
909
            f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
1260
 
            try:
1261
 
                ignore_globs.update(ignores.parse_ignore_file(f))
1262
 
            finally:
1263
 
                f.close()
1264
 
 
1265
 
        self._ignoreset = ignore_globs
1266
 
        self._ignore_regex = self._combine_ignore_rules(ignore_globs)
1267
 
        return ignore_globs
1268
 
 
1269
 
    def _get_ignore_rules_as_regex(self):
1270
 
        """Return a regex of the ignore rules and a mapping dict.
1271
 
 
1272
 
        :return: (ignore rules compiled regex, dictionary mapping rule group 
1273
 
        indices to original rule.)
1274
 
        """
1275
 
        if getattr(self, '_ignoreset', None) is None:
1276
 
            self.get_ignore_list()
1277
 
        return self._ignore_regex
 
910
            l.extend([line.rstrip("\n\r") for line in f.readlines()])
 
911
        self._ignorelist = l
 
912
        return l
 
913
 
1278
914
 
1279
915
    def is_ignored(self, filename):
1280
916
        r"""Check whether the filename matches an ignore pattern.
1294
930
        # treat dotfiles correctly and allows * to match /.
1295
931
        # Eventually it should be replaced with something more
1296
932
        # accurate.
1297
 
    
1298
 
        rules = self._get_ignore_rules_as_regex()
1299
 
        for regex, mapping in rules:
1300
 
            match = regex.match(filename)
1301
 
            if match is not None:
1302
 
                # one or more of the groups in mapping will have a non-None
1303
 
                # group match.
1304
 
                groups = match.groups()
1305
 
                rules = [mapping[group] for group in 
1306
 
                    mapping if groups[group] is not None]
1307
 
                return rules[0]
1308
 
        return None
 
933
        
 
934
        for pat in self.get_ignore_list():
 
935
            if '/' in pat or '\\' in pat:
 
936
                
 
937
                # as a special case, you can put ./ at the start of a
 
938
                # pattern; this is good to match in the top-level
 
939
                # only;
 
940
                
 
941
                if (pat[:2] == './') or (pat[:2] == '.\\'):
 
942
                    newpat = pat[2:]
 
943
                else:
 
944
                    newpat = pat
 
945
                if fnmatch.fnmatchcase(filename, newpat):
 
946
                    return pat
 
947
            else:
 
948
                if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
 
949
                    return pat
 
950
        else:
 
951
            return None
1309
952
 
1310
953
    def kind(self, file_id):
1311
954
        return file_kind(self.id2abspath(file_id))
1312
955
 
 
956
    @needs_read_lock
1313
957
    def last_revision(self):
1314
 
        """Return the last revision of the branch for this tree.
1315
 
 
1316
 
        This format tree does not support a separate marker for last-revision
1317
 
        compared to the branch.
1318
 
 
1319
 
        See MutableTree.last_revision
 
958
        """Return the last revision id of this working tree.
 
959
 
 
960
        In early branch formats this was == the branch last_revision,
 
961
        but that cannot be relied upon - for working tree operations,
 
962
        always use tree.last_revision().
1320
963
        """
1321
 
        return self._last_revision()
1322
 
 
1323
 
    @needs_read_lock
1324
 
    def _last_revision(self):
1325
 
        """helper for get_parent_ids."""
1326
964
        return self.branch.last_revision()
1327
965
 
1328
 
    def is_locked(self):
1329
 
        return self._control_files.is_locked()
1330
 
 
1331
966
    def lock_read(self):
1332
967
        """See Branch.lock_read, and WorkingTree.unlock."""
1333
968
        self.branch.lock_read()
1337
972
            self.branch.unlock()
1338
973
            raise
1339
974
 
1340
 
    def lock_tree_write(self):
1341
 
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
1342
 
        self.branch.lock_read()
1343
 
        try:
1344
 
            return self._control_files.lock_write()
1345
 
        except:
1346
 
            self.branch.unlock()
1347
 
            raise
1348
 
 
1349
975
    def lock_write(self):
1350
 
        """See MutableTree.lock_write, and WorkingTree.unlock."""
 
976
        """See Branch.lock_write, and WorkingTree.unlock."""
1351
977
        self.branch.lock_write()
1352
978
        try:
1353
979
            return self._control_files.lock_write()
1355
981
            self.branch.unlock()
1356
982
            raise
1357
983
 
1358
 
    def get_physical_lock_status(self):
1359
 
        return self._control_files.get_physical_lock_status()
1360
 
 
1361
 
    def _basis_inventory_name(self):
1362
 
        return 'basis-inventory-cache'
1363
 
 
1364
 
    @needs_tree_write_lock
1365
 
    def set_last_revision(self, new_revision):
 
984
    def _basis_inventory_name(self, revision_id):
 
985
        return 'basis-inventory.%s' % revision_id
 
986
 
 
987
    @needs_write_lock
 
988
    def set_last_revision(self, new_revision, old_revision=None):
1366
989
        """Change the last revision in the working tree."""
 
990
        self._remove_old_basis(old_revision)
1367
991
        if self._change_last_revision(new_revision):
1368
992
            self._cache_basis_inventory(new_revision)
1369
993
 
1370
994
    def _change_last_revision(self, new_revision):
1371
 
        """Template method part of set_last_revision to perform the change.
1372
 
        
1373
 
        This is used to allow WorkingTree3 instances to not affect branch
1374
 
        when their last revision is set.
1375
 
        """
 
995
        """Template method part of set_last_revision to perform the change."""
1376
996
        if new_revision is None:
1377
997
            self.branch.set_revision_history([])
1378
998
            return False
 
999
        # current format is locked in with the branch
 
1000
        revision_history = self.branch.revision_history()
1379
1001
        try:
1380
 
            self.branch.generate_revision_history(new_revision)
1381
 
        except errors.NoSuchRevision:
1382
 
            # not present in the repo - dont try to set it deeper than the tip
1383
 
            self.branch.set_revision_history([new_revision])
 
1002
            position = revision_history.index(new_revision)
 
1003
        except ValueError:
 
1004
            raise errors.NoSuchRevision(self.branch, new_revision)
 
1005
        self.branch.set_revision_history(revision_history[:position + 1])
1384
1006
        return True
1385
1007
 
1386
1008
    def _cache_basis_inventory(self, new_revision):
1387
1009
        """Cache new_revision as the basis inventory."""
1388
 
        # TODO: this should allow the ready-to-use inventory to be passed in,
1389
 
        # as commit already has that ready-to-use [while the format is the
1390
 
        # same, that is].
1391
1010
        try:
1392
 
            # this double handles the inventory - unpack and repack - 
1393
 
            # but is easier to understand. We can/should put a conditional
1394
 
            # in here based on whether the inventory is in the latest format
1395
 
            # - perhaps we should repack all inventories on a repository
1396
 
            # upgrade ?
1397
 
            # the fast path is to copy the raw xml from the repository. If the
1398
 
            # xml contains 'revision_id="', then we assume the right 
1399
 
            # revision_id is set. We must check for this full string, because a
1400
 
            # root node id can legitimately look like 'revision_id' but cannot
1401
 
            # contain a '"'.
1402
1011
            xml = self.branch.repository.get_inventory_xml(new_revision)
1403
 
            firstline = xml.split('\n', 1)[0]
1404
 
            if (not 'revision_id="' in firstline or 
1405
 
                'format="6"' not in firstline):
1406
 
                inv = self.branch.repository.deserialise_inventory(
1407
 
                    new_revision, xml)
1408
 
                inv.revision_id = new_revision
1409
 
                xml = bzrlib.xml6.serializer_v6.write_inventory_to_string(inv)
1410
 
            assert isinstance(xml, str), 'serialised xml must be bytestring.'
1411
 
            path = self._basis_inventory_name()
1412
 
            sio = StringIO(xml)
1413
 
            self._control_files.put(path, sio)
1414
 
        except (errors.NoSuchRevision, errors.RevisionNotPresent):
 
1012
            path = self._basis_inventory_name(new_revision)
 
1013
            self._control_files.put_utf8(path, xml)
 
1014
        except WeaveRevisionNotPresent:
1415
1015
            pass
1416
1016
 
1417
 
    def read_basis_inventory(self):
 
1017
    def _remove_old_basis(self, old_revision):
 
1018
        """Remove the old basis inventory 'old_revision'."""
 
1019
        if old_revision is not None:
 
1020
            try:
 
1021
                path = self._basis_inventory_name(old_revision)
 
1022
                path = self._control_files._escape(path)
 
1023
                self._control_files._transport.delete(path)
 
1024
            except NoSuchFile:
 
1025
                pass
 
1026
 
 
1027
    def read_basis_inventory(self, revision_id):
1418
1028
        """Read the cached basis inventory."""
1419
 
        path = self._basis_inventory_name()
1420
 
        return self._control_files.get(path).read()
 
1029
        path = self._basis_inventory_name(revision_id)
 
1030
        return self._control_files.get_utf8(path).read()
1421
1031
        
1422
1032
    @needs_read_lock
1423
1033
    def read_working_inventory(self):
1429
1039
        self._set_inventory(result)
1430
1040
        return result
1431
1041
 
1432
 
    @needs_tree_write_lock
1433
 
    def remove(self, files, verbose=False, to_file=None):
 
1042
    @needs_write_lock
 
1043
    def remove(self, files, verbose=False):
1434
1044
        """Remove nominated files from the working inventory..
1435
1045
 
1436
1046
        This does not remove their text.  This does not run on XXX on what? RBC
1458
1068
                # TODO: Perhaps make this just a warning, and continue?
1459
1069
                # This tends to happen when 
1460
1070
                raise NotVersionedError(path=f)
 
1071
            mutter("remove inventory entry %s {%s}", quotefn(f), fid)
1461
1072
            if verbose:
1462
1073
                # having remove it, it must be either ignored or unknown
1463
1074
                if self.is_ignored(f):
1464
1075
                    new_status = 'I'
1465
1076
                else:
1466
1077
                    new_status = '?'
1467
 
                show_status(new_status, inv[fid].kind, f, to_file=to_file)
 
1078
                show_status(new_status, inv[fid].kind, quotefn(f))
1468
1079
            del inv[fid]
1469
1080
 
1470
1081
        self._write_inventory(inv)
1471
1082
 
1472
 
    @needs_tree_write_lock
 
1083
    @needs_write_lock
1473
1084
    def revert(self, filenames, old_tree=None, backups=True, 
1474
1085
               pb=DummyProgress()):
1475
1086
        from transform import revert
1476
 
        from conflicts import resolve
1477
1087
        if old_tree is None:
1478
1088
            old_tree = self.basis_tree()
1479
 
        conflicts = revert(self, old_tree, filenames, backups, pb)
 
1089
        revert(self, old_tree, filenames, backups, pb)
1480
1090
        if not len(filenames):
1481
 
            self.set_parent_ids(self.get_parent_ids()[:1])
1482
 
            resolve(self)
1483
 
        else:
1484
 
            resolve(self, filenames, ignore_misses=True)
1485
 
        return conflicts
 
1091
            self.set_pending_merges([])
1486
1092
 
1487
 
    # XXX: This method should be deprecated in favour of taking in a proper
1488
 
    # new Inventory object.
1489
 
    @needs_tree_write_lock
 
1093
    @needs_write_lock
1490
1094
    def set_inventory(self, new_inventory_list):
1491
1095
        from bzrlib.inventory import (Inventory,
1492
1096
                                      InventoryDirectory,
1509
1113
                raise BzrError("unknown kind %r" % kind)
1510
1114
        self._write_inventory(inv)
1511
1115
 
1512
 
    @needs_tree_write_lock
 
1116
    @needs_write_lock
1513
1117
    def set_root_id(self, file_id):
1514
1118
        """Set the root id for this tree."""
1515
1119
        inv = self.read_working_inventory()
1532
1136
        between multiple working trees, i.e. via shared storage, then we 
1533
1137
        would probably want to lock both the local tree, and the branch.
1534
1138
        """
1535
 
        raise NotImplementedError(self.unlock)
 
1139
        # FIXME: We want to write out the hashcache only when the last lock on
 
1140
        # this working copy is released.  Peeking at the lock count is a bit
 
1141
        # of a nasty hack; probably it's better to have a transaction object,
 
1142
        # which can do some finalization when it's either successfully or
 
1143
        # unsuccessfully completed.  (Denys's original patch did that.)
 
1144
        # RBC 20060206 hookinhg into transaction will couple lock and transaction
 
1145
        # wrongly. Hookinh into unllock on the control files object is fine though.
 
1146
        
 
1147
        # TODO: split this per format so there is no ugly if block
 
1148
        if self._hashcache.needs_write and (
 
1149
            # dedicated lock files
 
1150
            self._control_files._lock_count==1 or 
 
1151
            # shared lock files
 
1152
            (self._control_files is self.branch.control_files and 
 
1153
             self._control_files._lock_count==3)):
 
1154
            self._hashcache.write()
 
1155
        # reverse order of locking.
 
1156
        result = self._control_files.unlock()
 
1157
        try:
 
1158
            self.branch.unlock()
 
1159
        finally:
 
1160
            return result
1536
1161
 
1537
1162
    @needs_write_lock
1538
1163
    def update(self):
1539
 
        """Update a working tree along its branch.
1540
 
 
1541
 
        This will update the branch if its bound too, which means we have multiple trees involved:
1542
 
        The new basis tree of the master.
1543
 
        The old basis tree of the branch.
1544
 
        The old basis tree of the working tree.
1545
 
        The current working tree state.
1546
 
        pathologically all three may be different, and non ancestors of each other.
1547
 
        Conceptually we want to:
1548
 
        Preserve the wt.basis->wt.state changes
1549
 
        Transform the wt.basis to the new master basis.
1550
 
        Apply a merge of the old branch basis to get any 'local' changes from it into the tree.
1551
 
        Restore the wt.basis->wt.state changes.
1552
 
 
1553
 
        There isn't a single operation at the moment to do that, so we:
1554
 
        Merge current state -> basis tree of the master w.r.t. the old tree basis.
1555
 
        Do a 'normal' merge of the old branch basis if it is relevant.
1556
 
        """
1557
 
        old_tip = self.branch.update()
1558
 
        # here if old_tip is not None, it is the old tip of the branch before
1559
 
        # it was updated from the master branch. This should become a pending
1560
 
        # merge in the working tree to preserve the user existing work.  we
1561
 
        # cant set that until we update the working trees last revision to be
1562
 
        # one from the new branch, because it will just get absorbed by the
1563
 
        # parent de-duplication logic.
1564
 
        # 
1565
 
        # We MUST save it even if an error occurs, because otherwise the users
1566
 
        # local work is unreferenced and will appear to have been lost.
1567
 
        # 
1568
 
        result = 0
 
1164
        self.branch.lock_read()
1569
1165
        try:
1570
 
            last_rev = self.get_parent_ids()[0]
1571
 
        except IndexError:
1572
 
            last_rev = None
1573
 
        if last_rev != self.branch.last_revision():
1574
 
            # merge tree state up to new branch tip.
 
1166
            if self.last_revision() == self.branch.last_revision():
 
1167
                return
1575
1168
            basis = self.basis_tree()
1576
1169
            to_tree = self.branch.basis_tree()
1577
 
            result += merge_inner(self.branch,
1578
 
                                  to_tree,
1579
 
                                  basis,
1580
 
                                  this_tree=self)
1581
 
            # TODO - dedup parents list with things merged by pull ?
1582
 
            # reuse the tree we've updated to to set the basis:
1583
 
            parent_trees = [(self.branch.last_revision(), to_tree)]
1584
 
            merges = self.get_parent_ids()[1:]
1585
 
            # Ideally we ask the tree for the trees here, that way the working
1586
 
            # tree can decide whether to give us teh entire tree or give us a
1587
 
            # lazy initialised tree. dirstate for instance will have the trees
1588
 
            # in ram already, whereas a last-revision + basis-inventory tree
1589
 
            # will not, but also does not need them when setting parents.
1590
 
            for parent in merges:
1591
 
                parent_trees.append(
1592
 
                    (parent, self.branch.repository.revision_tree(parent)))
1593
 
            if old_tip is not None:
1594
 
                parent_trees.append(
1595
 
                    (old_tip, self.branch.repository.revision_tree(old_tip)))
1596
 
            self.set_parent_trees(parent_trees)
1597
 
            last_rev = parent_trees[0][0]
1598
 
        else:
1599
 
            # the working tree had the same last-revision as the master
1600
 
            # branch did. We may still have pivot local work from the local
1601
 
            # branch into old_tip:
1602
 
            if old_tip is not None:
1603
 
                self.add_parent_tree_id(old_tip)
1604
 
        if old_tip and old_tip != last_rev:
1605
 
            # our last revision was not the prior branch last revision
1606
 
            # and we have converted that last revision to a pending merge.
1607
 
            # base is somewhere between the branch tip now
1608
 
            # and the now pending merge
1609
 
            from bzrlib.revision import common_ancestor
1610
 
            try:
1611
 
                base_rev_id = common_ancestor(self.branch.last_revision(),
1612
 
                                              old_tip,
1613
 
                                              self.branch.repository)
1614
 
            except errors.NoCommonAncestor:
1615
 
                base_rev_id = None
1616
 
            base_tree = self.branch.repository.revision_tree(base_rev_id)
1617
 
            other_tree = self.branch.repository.revision_tree(old_tip)
1618
 
            result += merge_inner(self.branch,
1619
 
                                  other_tree,
1620
 
                                  base_tree,
1621
 
                                  this_tree=self)
1622
 
        return result
 
1170
            result = merge_inner(self.branch,
 
1171
                                 to_tree,
 
1172
                                 basis,
 
1173
                                 this_tree=self)
 
1174
            self.set_last_revision(self.branch.last_revision())
 
1175
            return result
 
1176
        finally:
 
1177
            self.branch.unlock()
1623
1178
 
1624
 
    @needs_tree_write_lock
 
1179
    @needs_write_lock
1625
1180
    def _write_inventory(self, inv):
1626
1181
        """Write inventory as the current inventory."""
1627
1182
        sio = StringIO()
1631
1186
        self._set_inventory(inv)
1632
1187
        mutter('wrote working inventory')
1633
1188
 
1634
 
    def set_conflicts(self, arg):
1635
 
        raise UnsupportedOperation(self.set_conflicts, self)
1636
 
 
1637
 
    def add_conflicts(self, arg):
1638
 
        raise UnsupportedOperation(self.add_conflicts, self)
1639
 
 
1640
 
    @needs_read_lock
1641
 
    def conflicts(self):
1642
 
        conflicts = ConflictList()
1643
 
        for conflicted in self._iter_conflicts():
1644
 
            text = True
1645
 
            try:
1646
 
                if file_kind(self.abspath(conflicted)) != "file":
1647
 
                    text = False
1648
 
            except errors.NoSuchFile:
1649
 
                text = False
1650
 
            if text is True:
1651
 
                for suffix in ('.THIS', '.OTHER'):
1652
 
                    try:
1653
 
                        kind = file_kind(self.abspath(conflicted+suffix))
1654
 
                        if kind != "file":
1655
 
                            text = False
1656
 
                    except errors.NoSuchFile:
1657
 
                        text = False
1658
 
                    if text == False:
1659
 
                        break
1660
 
            ctype = {True: 'text conflict', False: 'contents conflict'}[text]
1661
 
            conflicts.append(Conflict.factory(ctype, path=conflicted,
1662
 
                             file_id=self.path2id(conflicted)))
1663
 
        return conflicts
1664
 
 
1665
 
 
1666
 
class WorkingTree2(WorkingTree):
1667
 
    """This is the Format 2 working tree.
1668
 
 
1669
 
    This was the first weave based working tree. 
1670
 
     - uses os locks for locking.
1671
 
     - uses the branch last-revision.
1672
 
    """
1673
 
 
1674
 
    def lock_tree_write(self):
1675
 
        """See WorkingTree.lock_tree_write().
1676
 
 
1677
 
        In Format2 WorkingTrees we have a single lock for the branch and tree
1678
 
        so lock_tree_write() degrades to lock_write().
1679
 
        """
1680
 
        self.branch.lock_write()
1681
 
        try:
1682
 
            return self._control_files.lock_write()
1683
 
        except:
1684
 
            self.branch.unlock()
1685
 
            raise
1686
 
 
1687
 
    def unlock(self):
1688
 
        # we share control files:
1689
 
        if self._hashcache.needs_write and self._control_files._lock_count==3:
1690
 
            self._hashcache.write()
1691
 
        # reverse order of locking.
1692
 
        try:
1693
 
            return self._control_files.unlock()
1694
 
        finally:
1695
 
            self.branch.unlock()
1696
 
 
1697
1189
 
1698
1190
class WorkingTree3(WorkingTree):
1699
1191
    """This is the Format 3 working tree.
1701
1193
    This differs from the base WorkingTree by:
1702
1194
     - having its own file lock
1703
1195
     - having its own last-revision property.
1704
 
 
1705
 
    This is new in bzr 0.8
1706
1196
    """
1707
1197
 
1708
1198
    @needs_read_lock
1709
 
    def _last_revision(self):
1710
 
        """See Mutable.last_revision."""
 
1199
    def last_revision(self):
 
1200
        """See WorkingTree.last_revision."""
1711
1201
        try:
1712
1202
            return self._control_files.get_utf8('last-revision').read()
1713
1203
        except NoSuchFile:
1722
1212
                pass
1723
1213
            return False
1724
1214
        else:
 
1215
            try:
 
1216
                self.branch.revision_history().index(revision_id)
 
1217
            except ValueError:
 
1218
                raise errors.NoSuchRevision(self.branch, revision_id)
1725
1219
            self._control_files.put_utf8('last-revision', revision_id)
1726
1220
            return True
1727
1221
 
1728
 
    @needs_tree_write_lock
1729
 
    def set_conflicts(self, conflicts):
1730
 
        self._put_rio('conflicts', conflicts.to_stanzas(), 
1731
 
                      CONFLICT_HEADER_1)
1732
 
 
1733
 
    @needs_tree_write_lock
1734
 
    def add_conflicts(self, new_conflicts):
1735
 
        conflict_set = set(self.conflicts())
1736
 
        conflict_set.update(set(list(new_conflicts)))
1737
 
        self.set_conflicts(ConflictList(sorted(conflict_set,
1738
 
                                               key=Conflict.sort_key)))
1739
 
 
1740
 
    @needs_read_lock
1741
 
    def conflicts(self):
1742
 
        try:
1743
 
            confile = self._control_files.get('conflicts')
1744
 
        except NoSuchFile:
1745
 
            return ConflictList()
1746
 
        try:
1747
 
            if confile.next() != CONFLICT_HEADER_1 + '\n':
1748
 
                raise ConflictFormatError()
1749
 
        except StopIteration:
1750
 
            raise ConflictFormatError()
1751
 
        return ConflictList.from_stanzas(RioReader(confile))
1752
 
 
1753
 
    def unlock(self):
1754
 
        if self._hashcache.needs_write and self._control_files._lock_count==1:
1755
 
            self._hashcache.write()
1756
 
        # reverse order of locking.
1757
 
        try:
1758
 
            return self._control_files.unlock()
1759
 
        finally:
1760
 
            self.branch.unlock()
1761
 
 
1762
 
 
 
1222
 
 
1223
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
1763
1224
def get_conflicted_stem(path):
1764
1225
    for suffix in CONFLICT_SUFFIXES:
1765
1226
        if path.endswith(suffix):
1815
1276
        except NoSuchFile:
1816
1277
            raise errors.NoWorkingTree(base=transport.base)
1817
1278
        except KeyError:
1818
 
            raise errors.UnknownFormatError(format=format_string)
 
1279
            raise errors.UnknownFormatError(format_string)
1819
1280
 
1820
1281
    @classmethod
1821
1282
    def get_default_format(klass):
1826
1287
        """Return the ASCII format string that identifies this format."""
1827
1288
        raise NotImplementedError(self.get_format_string)
1828
1289
 
1829
 
    def get_format_description(self):
1830
 
        """Return the short description for this format."""
1831
 
        raise NotImplementedError(self.get_format_description)
1832
 
 
1833
1290
    def is_supported(self):
1834
1291
        """Is this format supported?
1835
1292
 
1860
1317
    This format modified the hash cache from the format 1 hash cache.
1861
1318
    """
1862
1319
 
1863
 
    def get_format_description(self):
1864
 
        """See WorkingTreeFormat.get_format_description()."""
1865
 
        return "Working tree format 2"
1866
 
 
1867
 
    def stub_initialize_remote(self, control_files):
1868
 
        """As a special workaround create critical control files for a remote working tree
1869
 
        
1870
 
        This ensures that it can later be updated and dealt with locally,
1871
 
        since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with 
1872
 
        no working tree.  (See bug #43064).
1873
 
        """
1874
 
        sio = StringIO()
1875
 
        inv = Inventory()
1876
 
        bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
1877
 
        sio.seek(0)
1878
 
        control_files.put('inventory', sio)
1879
 
 
1880
 
        control_files.put_utf8('pending-merges', '')
1881
 
        
1882
 
 
1883
1320
    def initialize(self, a_bzrdir, revision_id=None):
1884
1321
        """See WorkingTreeFormat.initialize()."""
1885
1322
        if not isinstance(a_bzrdir.transport, LocalTransport):
1897
1334
            finally:
1898
1335
                branch.unlock()
1899
1336
        revision = branch.last_revision()
1900
 
        inv = Inventory()
1901
 
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
 
1337
        inv = Inventory() 
 
1338
        wt = WorkingTree(a_bzrdir.root_transport.base,
1902
1339
                         branch,
1903
1340
                         inv,
1904
1341
                         _internal=True,
1906
1343
                         _bzrdir=a_bzrdir)
1907
1344
        wt._write_inventory(inv)
1908
1345
        wt.set_root_id(inv.root.file_id)
1909
 
        basis_tree = branch.repository.revision_tree(revision)
1910
 
        wt.set_parent_trees([(revision, basis_tree)])
1911
 
        build_tree(basis_tree, wt)
 
1346
        wt.set_last_revision(revision)
 
1347
        wt.set_pending_merges([])
 
1348
        build_tree(wt.basis_tree(), wt)
1912
1349
        return wt
1913
1350
 
1914
1351
    def __init__(self):
1926
1363
            raise NotImplementedError
1927
1364
        if not isinstance(a_bzrdir.transport, LocalTransport):
1928
1365
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
1929
 
        return WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
 
1366
        return WorkingTree(a_bzrdir.root_transport.base,
1930
1367
                           _internal=True,
1931
1368
                           _format=self,
1932
1369
                           _bzrdir=a_bzrdir)
1935
1372
class WorkingTreeFormat3(WorkingTreeFormat):
1936
1373
    """The second working tree format updated to record a format marker.
1937
1374
 
1938
 
    This format:
1939
 
        - exists within a metadir controlling .bzr
1940
 
        - includes an explicit version marker for the workingtree control
1941
 
          files, separate from the BzrDir format
1942
 
        - modifies the hash cache format
1943
 
        - is new in bzr 0.8
1944
 
        - uses a LockDir to guard access for writes.
 
1375
    This format modified the hash cache from the format 1 hash cache.
1945
1376
    """
1946
1377
 
1947
1378
    def get_format_string(self):
1948
1379
        """See WorkingTreeFormat.get_format_string()."""
1949
1380
        return "Bazaar-NG Working Tree format 3"
1950
1381
 
1951
 
    def get_format_description(self):
1952
 
        """See WorkingTreeFormat.get_format_description()."""
1953
 
        return "Working tree format 3"
1954
 
 
1955
 
    _lock_file_name = 'lock'
1956
 
    _lock_class = LockDir
1957
 
 
1958
 
    def _open_control_files(self, a_bzrdir):
1959
 
        transport = a_bzrdir.get_workingtree_transport(None)
1960
 
        return LockableFiles(transport, self._lock_file_name, 
1961
 
                             self._lock_class)
1962
 
 
1963
1382
    def initialize(self, a_bzrdir, revision_id=None):
1964
1383
        """See WorkingTreeFormat.initialize().
1965
1384
        
1966
 
        revision_id allows creating a working tree at a different
 
1385
        revision_id allows creating a working tree at a differnet
1967
1386
        revision than the branch is at.
1968
1387
        """
1969
1388
        if not isinstance(a_bzrdir.transport, LocalTransport):
1970
1389
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
1971
1390
        transport = a_bzrdir.get_workingtree_transport(self)
1972
 
        control_files = self._open_control_files(a_bzrdir)
1973
 
        control_files.create_lock()
1974
 
        control_files.lock_write()
 
1391
        control_files = LockableFiles(transport, 'lock')
1975
1392
        control_files.put_utf8('format', self.get_format_string())
1976
1393
        branch = a_bzrdir.open_branch()
1977
1394
        if revision_id is None:
1978
1395
            revision_id = branch.last_revision()
1979
1396
        inv = Inventory() 
1980
 
        wt = WorkingTree3(a_bzrdir.root_transport.local_abspath('.'),
 
1397
        wt = WorkingTree3(a_bzrdir.root_transport.base,
1981
1398
                         branch,
1982
1399
                         inv,
1983
1400
                         _internal=True,
1984
1401
                         _format=self,
1985
 
                         _bzrdir=a_bzrdir,
1986
 
                         _control_files=control_files)
1987
 
        wt.lock_tree_write()
1988
 
        try:
1989
 
            wt._write_inventory(inv)
1990
 
            wt.set_root_id(inv.root.file_id)
1991
 
            basis_tree = branch.repository.revision_tree(revision_id)
1992
 
            if revision_id == bzrlib.revision.NULL_REVISION:
1993
 
                wt.set_parent_trees([])
1994
 
            else:
1995
 
                wt.set_parent_trees([(revision_id, basis_tree)])
1996
 
            build_tree(basis_tree, wt)
1997
 
        finally:
1998
 
            wt.unlock()
1999
 
            control_files.unlock()
 
1402
                         _bzrdir=a_bzrdir)
 
1403
        wt._write_inventory(inv)
 
1404
        wt.set_root_id(inv.root.file_id)
 
1405
        wt.set_last_revision(revision_id)
 
1406
        wt.set_pending_merges([])
 
1407
        build_tree(wt.basis_tree(), wt)
2000
1408
        return wt
2001
1409
 
2002
1410
    def __init__(self):
2014
1422
            raise NotImplementedError
2015
1423
        if not isinstance(a_bzrdir.transport, LocalTransport):
2016
1424
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
2017
 
        return self._open(a_bzrdir, self._open_control_files(a_bzrdir))
2018
 
 
2019
 
    def _open(self, a_bzrdir, control_files):
2020
 
        """Open the tree itself.
2021
 
        
2022
 
        :param a_bzrdir: the dir for the tree.
2023
 
        :param control_files: the control files for the tree.
2024
 
        """
2025
 
        return WorkingTree3(a_bzrdir.root_transport.local_abspath('.'),
 
1425
        return WorkingTree3(a_bzrdir.root_transport.base,
2026
1426
                           _internal=True,
2027
1427
                           _format=self,
2028
 
                           _bzrdir=a_bzrdir,
2029
 
                           _control_files=control_files)
 
1428
                           _bzrdir=a_bzrdir)
2030
1429
 
2031
1430
    def __str__(self):
2032
1431
        return self.get_format_string()
2055
1454
        self._transport_readonly_server = transport_readonly_server
2056
1455
        self._formats = formats
2057
1456
    
2058
 
    def _clone_test(self, test, bzrdir_format, workingtree_format, variation):
2059
 
        """Clone test for adaption."""
2060
 
        new_test = deepcopy(test)
2061
 
        new_test.transport_server = self._transport_server
2062
 
        new_test.transport_readonly_server = self._transport_readonly_server
2063
 
        new_test.bzrdir_format = bzrdir_format
2064
 
        new_test.workingtree_format = workingtree_format
2065
 
        def make_new_test_id():
2066
 
            new_id = "%s(%s)" % (test.id(), variation)
2067
 
            return lambda: new_id
2068
 
        new_test.id = make_new_test_id()
2069
 
        return new_test
2070
 
    
2071
1457
    def adapt(self, test):
2072
1458
        from bzrlib.tests import TestSuite
2073
1459
        result = TestSuite()
2074
1460
        for workingtree_format, bzrdir_format in self._formats:
2075
 
            new_test = self._clone_test(
2076
 
                test,
2077
 
                bzrdir_format,
2078
 
                workingtree_format, workingtree_format.__class__.__name__)
 
1461
            new_test = deepcopy(test)
 
1462
            new_test.transport_server = self._transport_server
 
1463
            new_test.transport_readonly_server = self._transport_readonly_server
 
1464
            new_test.bzrdir_format = bzrdir_format
 
1465
            new_test.workingtree_format = workingtree_format
 
1466
            def make_new_test_id():
 
1467
                new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
 
1468
                return lambda: new_id
 
1469
            new_test.id = make_new_test_id()
2079
1470
            result.addTest(new_test)
2080
1471
        return result