~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Martin Pool
  • Date: 2005-09-29 09:07:09 UTC
  • mto: (1185.12.2) (1393.1.12)
  • mto: This revision was merged to the branch mainline in revision 1396.
  • Revision ID: mbp@sourcefrog.net-20050929090709-36eebfb3ba67d0a5
- weave tool now finds bzrlib if it's not on the default path

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
 
import stat
47
24
import fnmatch
48
 
 
49
 
from bzrlib.branch import Branch, needs_read_lock, needs_write_lock, quotefn
 
25
        
50
26
import bzrlib.tree
51
 
from bzrlib.osutils import appendpath, file_kind, isdir, splitpath, relpath
52
 
from bzrlib.errors import BzrCheckError, DivergedBranches, NotVersionedError
 
27
from bzrlib.osutils import appendpath, file_kind, isdir, splitpath
 
28
from bzrlib.errors import BzrCheckError
53
29
from bzrlib.trace import mutter
54
30
 
55
 
 
56
 
class TreeEntry(object):
57
 
    """An entry that implements the minium interface used by commands.
58
 
 
59
 
    This needs further inspection, it may be better to have 
60
 
    InventoryEntries without ids - though that seems wrong. For now,
61
 
    this is a parallel hierarchy to InventoryEntry, and needs to become
62
 
    one of several things: decorates to that hierarchy, children of, or
63
 
    parents of it.
64
 
    Another note is that these objects are currently only used when there is
65
 
    no InventoryEntry available - i.e. for unversioned objects.
66
 
    Perhaps they should be UnversionedEntry et al. ? - RBC 20051003
67
 
    """
68
 
 
69
 
    def __eq__(self, other):
70
 
        # yes, this us ugly, TODO: best practice __eq__ style.
71
 
        return (isinstance(other, TreeEntry)
72
 
                and other.__class__ == self.__class__)
73
 
 
74
 
    def kind_character(self):
75
 
        return "???"
76
 
 
77
 
 
78
 
class TreeDirectory(TreeEntry):
79
 
    """See TreeEntry. This is a directory in a working tree."""
80
 
 
81
 
    def __eq__(self, other):
82
 
        return (isinstance(other, TreeDirectory)
83
 
                and other.__class__ == self.__class__)
84
 
 
85
 
    def kind_character(self):
86
 
        return "/"
87
 
 
88
 
 
89
 
class TreeFile(TreeEntry):
90
 
    """See TreeEntry. This is a regular file in a working tree."""
91
 
 
92
 
    def __eq__(self, other):
93
 
        return (isinstance(other, TreeFile)
94
 
                and other.__class__ == self.__class__)
95
 
 
96
 
    def kind_character(self):
97
 
        return ''
98
 
 
99
 
 
100
 
class TreeLink(TreeEntry):
101
 
    """See TreeEntry. This is a symlink in a working tree."""
102
 
 
103
 
    def __eq__(self, other):
104
 
        return (isinstance(other, TreeLink)
105
 
                and other.__class__ == self.__class__)
106
 
 
107
 
    def kind_character(self):
108
 
        return ''
109
 
 
110
 
 
111
31
class WorkingTree(bzrlib.tree.Tree):
112
32
    """Working copy tree.
113
33
 
117
37
    It is possible for a `WorkingTree` to have a filename which is
118
38
    not listed in the Inventory and vice versa.
119
39
    """
120
 
 
121
 
    def __init__(self, basedir, branch=None):
122
 
        """Construct a WorkingTree for basedir.
123
 
 
124
 
        If the branch is not supplied, it is opened automatically.
125
 
        If the branch is supplied, it must be the branch for this basedir.
126
 
        (branch.base is not cross checked, because for remote branches that
127
 
        would be meaningless).
128
 
        """
 
40
    def __init__(self, basedir, inv):
129
41
        from bzrlib.hashcache import HashCache
130
42
        from bzrlib.trace import note, mutter
131
 
        assert isinstance(basedir, basestring), \
132
 
            "base directory %r is not a string" % basedir
133
 
        if branch is None:
134
 
            branch = Branch.open(basedir)
135
 
        assert isinstance(branch, Branch), \
136
 
            "branch %r is not a Branch" % branch
137
 
        self._inventory = branch.inventory
138
 
        self.path2id = self._inventory.path2id
139
 
        self.branch = branch
 
43
 
 
44
        self._inventory = inv
140
45
        self.basedir = basedir
 
46
        self.path2id = inv.path2id
141
47
 
142
48
        # update the whole cache up front and write to disk if anything changed;
143
49
        # 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
50
        hc = self._hashcache = HashCache(basedir)
149
51
        hc.read()
150
52
        hc.scan()
152
54
        if hc.needs_write:
153
55
            mutter("write hc")
154
56
            hc.write()
 
57
            
 
58
            
 
59
    def __del__(self):
 
60
        if self._hashcache.needs_write:
 
61
            self._hashcache.write()
 
62
 
155
63
 
156
64
    def __iter__(self):
157
65
        """Iterate through file_ids for this tree.
161
69
        """
162
70
        inv = self._inventory
163
71
        for path, ie in inv.iter_entries():
164
 
            if bzrlib.osutils.lexists(self.abspath(path)):
 
72
            if os.path.exists(self.abspath(path)):
165
73
                yield ie.file_id
166
74
 
167
75
 
174
82
    def abspath(self, filename):
175
83
        return os.path.join(self.basedir, filename)
176
84
 
177
 
    def relpath(self, abspath):
178
 
        """Return the local path portion from a given absolute path."""
179
 
        return relpath(self.basedir, abspath)
180
 
 
181
85
    def has_filename(self, filename):
182
 
        return bzrlib.osutils.lexists(self.abspath(filename))
 
86
        return os.path.exists(self.abspath(filename))
183
87
 
184
88
    def get_file(self, file_id):
185
89
        return self.get_file_byname(self.id2path(file_id))
202
106
        if not inv.has_id(file_id):
203
107
            return False
204
108
        path = inv.id2path(file_id)
205
 
        return bzrlib.osutils.lexists(self.abspath(path))
 
109
        return os.path.exists(self.abspath(path))
206
110
 
207
 
    def has_or_had_id(self, file_id):
208
 
        if file_id == self.inventory.root.file_id:
209
 
            return True
210
 
        return self.inventory.has_id(file_id)
211
111
 
212
112
    __contains__ = has_id
213
113
    
215
115
    def get_file_size(self, file_id):
216
116
        return os.path.getsize(self.id2abspath(file_id))
217
117
 
 
118
 
218
119
    def get_file_sha1(self, file_id):
219
120
        path = self._inventory.id2path(file_id)
220
121
        return self._hashcache.get_sha1(path)
221
122
 
222
123
 
223
 
    def is_executable(self, file_id):
224
 
        if os.name == "nt":
225
 
            return self._inventory[file_id].executable
226
 
        else:
227
 
            path = self._inventory.id2path(file_id)
228
 
            mode = os.lstat(self.abspath(path)).st_mode
229
 
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC&mode)
230
 
 
231
 
    def get_symlink_target(self, file_id):
232
 
        return os.readlink(self.id2abspath(file_id))
233
 
 
234
124
    def file_class(self, filename):
235
125
        if self.path2id(filename):
236
126
            return 'V'
284
174
                                            "now of kind %r"
285
175
                                            % (fap, f_ie.kind, f_ie.file_id, fk))
286
176
 
287
 
                # make a last minute entry
288
 
                if f_ie:
289
 
                    entry = f_ie
290
 
                else:
291
 
                    if fk == 'directory':
292
 
                        entry = TreeDirectory()
293
 
                    elif fk == 'file':
294
 
                        entry = TreeFile()
295
 
                    elif fk == 'symlink':
296
 
                        entry = TreeLink()
297
 
                    else:
298
 
                        entry = TreeEntry()
299
 
                
300
 
                yield fp, c, fk, (f_ie and f_ie.file_id), entry
 
177
                yield fp, c, fk, (f_ie and f_ie.file_id)
301
178
 
302
179
                if fk != 'directory':
303
180
                    continue
319
196
            if not self.is_ignored(subp):
320
197
                yield subp
321
198
 
322
 
    def iter_conflicts(self):
323
 
        conflicted = set()
324
 
        for path in (s[0] for s in self.list_files()):
325
 
            stem = get_conflicted_stem(path)
326
 
            if stem is None:
327
 
                continue
328
 
            if stem not in conflicted:
329
 
                conflicted.add(stem)
330
 
                yield stem
331
 
 
332
 
    @needs_write_lock
333
 
    def pull(self, source, remember=False, clobber=False):
334
 
        from bzrlib.merge import merge_inner
335
 
        source.lock_read()
336
 
        try:
337
 
            old_revision_history = self.branch.revision_history()
338
 
            try:
339
 
                self.branch.update_revisions(source)
340
 
            except DivergedBranches:
341
 
                if not clobber:
342
 
                    raise
343
 
                self.branch.set_revision_history(source.revision_history())
344
 
            new_revision_history = self.branch.revision_history()
345
 
            if new_revision_history != old_revision_history:
346
 
                if len(old_revision_history):
347
 
                    other_revision = old_revision_history[-1]
348
 
                else:
349
 
                    other_revision = None
350
 
                merge_inner(self.branch,
351
 
                            self.branch.basis_tree(), 
352
 
                            self.branch.revision_tree(other_revision))
353
 
            if self.branch.get_parent() is None or remember:
354
 
                self.branch.set_parent(source.base)
355
 
        finally:
356
 
            source.unlock()
357
199
 
358
200
    def extras(self):
359
201
        """Yield all unknown files in this WorkingTree.
445
287
                    return pat
446
288
        else:
447
289
            return None
448
 
 
449
 
    def kind(self, file_id):
450
 
        return file_kind(self.id2abspath(file_id))
451
 
 
452
 
    def lock_read(self):
453
 
        """See Branch.lock_read, and WorkingTree.unlock."""
454
 
        return self.branch.lock_read()
455
 
 
456
 
    def lock_write(self):
457
 
        """See Branch.lock_write, and WorkingTree.unlock."""
458
 
        return self.branch.lock_write()
459
 
 
460
 
    @needs_write_lock
461
 
    def remove(self, files, verbose=False):
462
 
        """Remove nominated files from the working inventory..
463
 
 
464
 
        This does not remove their text.  This does not run on XXX on what? RBC
465
 
 
466
 
        TODO: Refuse to remove modified files unless --force is given?
467
 
 
468
 
        TODO: Do something useful with directories.
469
 
 
470
 
        TODO: Should this remove the text or not?  Tough call; not
471
 
        removing may be useful and the user can just use use rm, and
472
 
        is the opposite of add.  Removing it is consistent with most
473
 
        other tools.  Maybe an option.
474
 
        """
475
 
        ## TODO: Normalize names
476
 
        ## TODO: Remove nested loops; better scalability
477
 
        if isinstance(files, basestring):
478
 
            files = [files]
479
 
 
480
 
        inv = self.inventory
481
 
 
482
 
        # do this before any modifications
483
 
        for f in files:
484
 
            fid = inv.path2id(f)
485
 
            if not fid:
486
 
                # TODO: Perhaps make this just a warning, and continue?
487
 
                # This tends to happen when 
488
 
                raise NotVersionedError(path=f)
489
 
            mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
490
 
            if verbose:
491
 
                # having remove it, it must be either ignored or unknown
492
 
                if self.is_ignored(f):
493
 
                    new_status = 'I'
494
 
                else:
495
 
                    new_status = '?'
496
 
                show_status(new_status, inv[fid].kind, quotefn(f))
497
 
            del inv[fid]
498
 
 
499
 
        self.branch._write_inventory(inv)
500
 
 
501
 
    def unlock(self):
502
 
        """See Branch.unlock.
503
290
        
504
 
        WorkingTree locking just uses the Branch locking facilities.
505
 
        This is current because all working trees have an embedded branch
506
 
        within them. IF in the future, we were to make branch data shareable
507
 
        between multiple working trees, i.e. via shared storage, then we 
508
 
        would probably want to lock both the local tree, and the branch.
509
 
        """
510
 
        return self.branch.unlock()
511
 
 
512
 
 
513
 
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
514
 
def get_conflicted_stem(path):
515
 
    for suffix in CONFLICT_SUFFIXES:
516
 
        if path.endswith(suffix):
517
 
            return path[:-len(suffix)]