← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Aaron Bentley
  • Date: 2005-09-10 22:55:35 UTC
  • mto: (1185.3.4)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: aaron.bentley@utoronto.ca-20050910225535-3660c70bf335c618
Handled ancestors that are missing when finding a base

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
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
# TODO: Don't allow WorkingTrees to be constructed for remote branches.
 
18
 
 
19
# FIXME: I don't know if writing out the cache from the destructor is really a
 
20
# good idea, because destructors are considered poor taste in Python, and
 
21
# it's not predictable when it will be written out.
17
22
 
18
23
import os
19
 
    
 
24
import fnmatch
 
25
        
20
26
import bzrlib.tree
21
 
from errors import BzrCheckError
22
 
from trace import mutter
23
 
import statcache
 
27
from bzrlib.osutils import appendpath, file_kind, isdir, splitpath
 
28
from bzrlib.errors import BzrCheckError
 
29
from bzrlib.trace import mutter
24
30
 
25
31
class WorkingTree(bzrlib.tree.Tree):
26
32
    """Working copy tree.
31
37
    It is possible for a `WorkingTree` to have a filename which is
32
38
    not listed in the Inventory and vice versa.
33
39
    """
34
 
    _statcache = None
35
 
    
36
40
    def __init__(self, basedir, inv):
 
41
        from bzrlib.hashcache import HashCache
 
42
        from bzrlib.trace import note, mutter
 
43
 
37
44
        self._inventory = inv
38
45
        self.basedir = basedir
39
46
        self.path2id = inv.path2id
40
 
        self._update_statcache()
 
47
 
 
48
        # update the whole cache up front and write to disk if anything changed;
 
49
        # in the future we might want to do this more selectively
 
50
        hc = self._hashcache = HashCache(basedir)
 
51
        hc.read()
 
52
        hc.scan()
 
53
 
 
54
        if hc.needs_write:
 
55
            mutter("write hc")
 
56
            hc.write()
 
57
            
 
58
            
 
59
    def __del__(self):
 
60
        if self._hashcache.needs_write:
 
61
            self._hashcache.write()
 
62
 
41
63
 
42
64
    def __iter__(self):
43
65
        """Iterate through file_ids for this tree.
46
68
        and the working file exists.
47
69
        """
48
70
        inv = self._inventory
49
 
        for file_id in self._inventory:
50
 
            # TODO: This is slightly redundant; we should be able to just
51
 
            # check the statcache but it only includes regular files.
52
 
            # only include files which still exist on disk
53
 
            ie = inv[file_id]
54
 
            if ie.kind == 'file':
55
 
                if ((file_id in self._statcache)
56
 
                    or (os.path.exists(self.abspath(inv.id2path(file_id))))):
57
 
                    yield file_id
58
 
 
 
71
        for path, ie in inv.iter_entries():
 
72
            if os.path.exists(self.abspath(path)):
 
73
                yield ie.file_id
59
74
 
60
75
 
61
76
    def __repr__(self):
62
77
        return "<%s of %s>" % (self.__class__.__name__,
63
 
                               self.basedir)
 
78
                               getattr(self, 'basedir', None))
 
79
 
 
80
 
64
81
 
65
82
    def abspath(self, filename):
66
83
        return os.path.join(self.basedir, filename)
81
98
                
82
99
    def has_id(self, file_id):
83
100
        # files that have been deleted are excluded
84
 
        if not self.inventory.has_id(file_id):
 
101
        inv = self._inventory
 
102
        if not inv.has_id(file_id):
85
103
            return False
86
 
        if file_id in self._statcache:
87
 
            return True
88
 
        return os.path.exists(self.abspath(self.id2path(file_id)))
 
104
        path = inv.id2path(file_id)
 
105
        return os.path.exists(self.abspath(path))
89
106
 
90
107
 
91
108
    __contains__ = has_id
92
109
    
93
110
 
94
 
    def _update_statcache(self):
95
 
        import statcache
96
 
        if not self._statcache:
97
 
            self._statcache = statcache.update_cache(self.basedir, self.inventory)
98
 
 
99
111
    def get_file_size(self, file_id):
100
 
        import os, stat
101
 
        return os.stat(self._get_store_filename(file_id))[stat.ST_SIZE]
 
112
        # is this still called?
 
113
        raise NotImplementedError()
102
114
 
103
115
 
104
116
    def get_file_sha1(self, file_id):
105
 
        return self._statcache[file_id][statcache.SC_SHA1]
 
117
        path = self._inventory.id2path(file_id)
 
118
        return self._hashcache.get_sha1(path)
106
119
 
107
120
 
108
121
    def file_class(self, filename):
124
137
 
125
138
        Skips the control directory.
126
139
        """
127
 
        from osutils import appendpath, file_kind
128
 
        import os
129
 
 
130
 
        inv = self.inventory
 
140
        inv = self._inventory
131
141
 
132
142
        def descend(from_dir_relpath, from_dir_id, dp):
133
143
            ls = os.listdir(dp)
194
204
        Currently returned depth-first, sorted by name within directories.
195
205
        """
196
206
        ## TODO: Work from given directory downwards
197
 
        from osutils import isdir, appendpath
198
 
        
199
207
        for path, dir_entry in self.inventory.directories():
200
208
            mutter("search for unknowns in %r" % path)
201
209
            dirabs = self.abspath(path)
258
266
        # Eventually it should be replaced with something more
259
267
        # accurate.
260
268
        
261
 
        import fnmatch
262
 
        from osutils import splitpath
263
 
        
264
269
        for pat in self.get_ignore_list():
265
270
            if '/' in pat or '\\' in pat:
266
271
                
280
285
        else:
281
286
            return None
282
287
        
283
 
 
284
 
        
285
 
        
286