~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Robert Collins
  • Date: 2005-10-17 11:56:54 UTC
  • mfrom: (1185.16.59)
  • Revision ID: robertc@robertcollins.net-20051017115654-662239e1587524a8
mergeĀ fromĀ martin.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
16
16
 
17
 
"""WorkingTree object and friends.
18
 
 
19
 
A WorkingTree represents the editable working copy of a branch.
20
 
Operations which represent the WorkingTree are also done here, 
21
 
such as renaming or adding files.  The WorkingTree has an inventory 
22
 
which is updated by these operations.  A commit produces a 
23
 
new revision based on the workingtree and its inventory.
24
 
 
25
 
At the moment every WorkingTree has its own branch.  Remote
26
 
WorkingTrees aren't supported.
27
 
 
28
 
To get a WorkingTree, call Branch.working_tree():
29
 
"""
30
 
 
31
 
 
32
 
# TODO: Don't allow WorkingTrees to be constructed for remote branches if 
33
 
# they don't work.
 
17
# TODO: Don't allow WorkingTrees to be constructed for remote branches.
34
18
 
35
19
# FIXME: I don't know if writing out the cache from the destructor is really a
36
 
# good idea, because destructors are considered poor taste in Python, and it's
37
 
# not predictable when it will be written out.
38
 
 
39
 
# TODO: Give the workingtree sole responsibility for the working inventory;
40
 
# remove the variable and references to it from the branch.  This may require
41
 
# updating the commit code so as to update the inventory within the working
42
 
# copy, and making sure there's only one WorkingTree for any directory on disk.
43
 
# At the momenthey may alias the inventory and have old copies of it in memory.
 
20
# good idea, because destructors are considered poor taste in Python, and
 
21
# it's not predictable when it will be written out.
44
22
 
45
23
import os
46
24
import stat
47
25
import fnmatch
48
26
 
49
 
from bzrlib.branch import Branch, needs_read_lock, needs_write_lock, quotefn
 
27
from bzrlib.branch import Branch
50
28
import bzrlib.tree
51
29
from bzrlib.osutils import appendpath, file_kind, isdir, splitpath, relpath
52
 
from bzrlib.errors import BzrCheckError, DivergedBranches, NotVersionedError
 
30
from bzrlib.errors import BzrCheckError
53
31
from bzrlib.trace import mutter
54
32
 
55
 
 
56
33
class TreeEntry(object):
57
34
    """An entry that implements the minium interface used by commands.
58
35
 
117
94
    It is possible for a `WorkingTree` to have a filename which is
118
95
    not listed in the Inventory and vice versa.
119
96
    """
120
 
 
121
97
    def __init__(self, basedir, branch=None):
122
98
        """Construct a WorkingTree for basedir.
123
99
 
128
104
        """
129
105
        from bzrlib.hashcache import HashCache
130
106
        from bzrlib.trace import note, mutter
131
 
        assert isinstance(basedir, basestring), \
132
 
            "base directory %r is not a string" % basedir
 
107
 
133
108
        if branch is None:
134
109
            branch = Branch.open(basedir)
135
 
        assert isinstance(branch, Branch), \
136
 
            "branch %r is not a Branch" % branch
137
110
        self._inventory = branch.inventory
138
111
        self.path2id = self._inventory.path2id
139
112
        self.branch = branch
141
114
 
142
115
        # update the whole cache up front and write to disk if anything changed;
143
116
        # in the future we might want to do this more selectively
144
 
        # two possible ways offer themselves : in self._unlock, write the cache
145
 
        # if needed, or, when the cache sees a change, append it to the hash
146
 
        # cache file, and have the parser take the most recent entry for a
147
 
        # given path only.
148
117
        hc = self._hashcache = HashCache(basedir)
149
118
        hc.read()
150
119
        hc.scan()
152
121
        if hc.needs_write:
153
122
            mutter("write hc")
154
123
            hc.write()
 
124
            
 
125
            
 
126
    def __del__(self):
 
127
        if self._hashcache.needs_write:
 
128
            self._hashcache.write()
 
129
 
155
130
 
156
131
    def __iter__(self):
157
132
        """Iterate through file_ids for this tree.
329
304
                conflicted.add(stem)
330
305
                yield stem
331
306
 
332
 
    @needs_write_lock
333
 
    def pull(self, source, overwrite=False):
334
 
        from bzrlib.merge import merge_inner
335
 
        source.lock_read()
336
 
        try:
337
 
            old_revision_history = self.branch.revision_history()
338
 
            self.branch.pull(source, overwrite)
339
 
            new_revision_history = self.branch.revision_history()
340
 
            if new_revision_history != old_revision_history:
341
 
                if len(old_revision_history):
342
 
                    other_revision = old_revision_history[-1]
343
 
                else:
344
 
                    other_revision = None
345
 
                merge_inner(self.branch,
346
 
                            self.branch.basis_tree(), 
347
 
                            self.branch.revision_tree(other_revision))
348
 
        finally:
349
 
            source.unlock()
350
 
 
351
307
    def extras(self):
352
308
        """Yield all unknown files in this WorkingTree.
353
309
 
442
398
    def kind(self, file_id):
443
399
        return file_kind(self.id2abspath(file_id))
444
400
 
445
 
    def lock_read(self):
446
 
        """See Branch.lock_read, and WorkingTree.unlock."""
447
 
        return self.branch.lock_read()
448
 
 
449
 
    def lock_write(self):
450
 
        """See Branch.lock_write, and WorkingTree.unlock."""
451
 
        return self.branch.lock_write()
452
 
 
453
 
    @needs_write_lock
454
 
    def remove(self, files, verbose=False):
455
 
        """Remove nominated files from the working inventory..
456
 
 
457
 
        This does not remove their text.  This does not run on XXX on what? RBC
458
 
 
459
 
        TODO: Refuse to remove modified files unless --force is given?
460
 
 
461
 
        TODO: Do something useful with directories.
462
 
 
463
 
        TODO: Should this remove the text or not?  Tough call; not
464
 
        removing may be useful and the user can just use use rm, and
465
 
        is the opposite of add.  Removing it is consistent with most
466
 
        other tools.  Maybe an option.
467
 
        """
468
 
        ## TODO: Normalize names
469
 
        ## TODO: Remove nested loops; better scalability
470
 
        if isinstance(files, basestring):
471
 
            files = [files]
472
 
 
473
 
        inv = self.inventory
474
 
 
475
 
        # do this before any modifications
476
 
        for f in files:
477
 
            fid = inv.path2id(f)
478
 
            if not fid:
479
 
                # TODO: Perhaps make this just a warning, and continue?
480
 
                # This tends to happen when 
481
 
                raise NotVersionedError(path=f)
482
 
            mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
483
 
            if verbose:
484
 
                # having remove it, it must be either ignored or unknown
485
 
                if self.is_ignored(f):
486
 
                    new_status = 'I'
487
 
                else:
488
 
                    new_status = '?'
489
 
                show_status(new_status, inv[fid].kind, quotefn(f))
490
 
            del inv[fid]
491
 
 
492
 
        self.branch._write_inventory(inv)
493
 
 
494
 
    def unlock(self):
495
 
        """See Branch.unlock.
496
 
        
497
 
        WorkingTree locking just uses the Branch locking facilities.
498
 
        This is current because all working trees have an embedded branch
499
 
        within them. IF in the future, we were to make branch data shareable
500
 
        between multiple working trees, i.e. via shared storage, then we 
501
 
        would probably want to lock both the local tree, and the branch.
502
 
        """
503
 
        return self.branch.unlock()
504
 
 
505
 
 
506
401
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
507
402
def get_conflicted_stem(path):
508
403
    for suffix in CONFLICT_SUFFIXES: