← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Martin Pool
  • Date: 2005-08-26 02:31:37 UTC
  • Revision ID: mbp@sourcefrog.net-20050826023137-eb4b101cc92f9792
- ignore tags files

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
    
21
26
from errors import BzrCheckError
22
27
from trace import mutter
23
28
 
24
 
 
25
29
class WorkingTree(bzrlib.tree.Tree):
26
30
    """Working copy tree.
27
31
 
31
35
    It is possible for a `WorkingTree` to have a filename which is
32
36
    not listed in the Inventory and vice versa.
33
37
    """
34
 
    _statcache = None
35
 
    
36
38
    def __init__(self, basedir, inv):
 
39
        from bzrlib.hashcache import HashCache
 
40
        from bzrlib.trace import note, mutter
 
41
 
37
42
        self._inventory = inv
38
43
        self.basedir = basedir
39
44
        self.path2id = inv.path2id
40
45
 
 
46
        # update the whole cache up front and write to disk if anything changed;
 
47
        # in the future we might want to do this more selectively
 
48
        hc = self._hashcache = HashCache(basedir)
 
49
        hc.read()
 
50
        hc.scan()
 
51
 
 
52
        if hc.needs_write:
 
53
            mutter("write hc")
 
54
            hc.write()
 
55
            
 
56
            
 
57
    def __del__(self):
 
58
        if self._hashcache.needs_write:
 
59
            self._hashcache.write()
 
60
 
 
61
 
41
62
    def __iter__(self):
42
63
        """Iterate through file_ids for this tree.
43
64
 
44
65
        file_ids are in a WorkingTree if they are in the working inventory
45
66
        and the working file exists.
46
67
        """
47
 
        self._update_statcache()
48
68
        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
 
 
 
69
        for path, ie in inv.iter_entries():
 
70
            if os.path.exists(self.abspath(path)):
 
71
                yield ie.file_id
59
72
 
60
73
 
61
74
    def __repr__(self):
62
75
        return "<%s of %s>" % (self.__class__.__name__,
63
 
                               self.basedir)
 
76
                               getattr(self, 'basedir', None))
 
77
 
 
78
 
64
79
 
65
80
    def abspath(self, filename):
66
81
        return os.path.join(self.basedir, filename)
81
96
                
82
97
    def has_id(self, file_id):
83
98
        # files that have been deleted are excluded
84
 
        if not self.inventory.has_id(file_id):
 
99
        inv = self._inventory
 
100
        if not inv.has_id(file_id):
85
101
            return False
86
 
        self._update_statcache()
87
 
        if file_id in self._statcache:
88
 
            return True
89
 
        return os.path.exists(self.abspath(self.id2path(file_id)))
 
102
        path = inv.id2path(file_id)
 
103
        return os.path.exists(self.abspath(path))
90
104
 
91
105
 
92
106
    __contains__ = has_id
93
107
    
94
108
 
95
 
    def _update_statcache(self):
96
 
        import statcache
97
 
        if not self._statcache:
98
 
            self._statcache = statcache.update_cache(self.basedir, self.inventory)
99
 
 
100
109
    def get_file_size(self, file_id):
101
 
        import os, stat
102
 
        return os.stat(self._get_store_filename(file_id))[stat.ST_SIZE]
 
110
        # is this still called?
 
111
        raise NotImplementedError()
103
112
 
104
113
 
105
114
    def get_file_sha1(self, file_id):
106
 
        import statcache
107
 
        self._update_statcache()
108
 
        return self._statcache[file_id][statcache.SC_SHA1]
 
115
        path = self._inventory.id2path(file_id)
 
116
        return self._hashcache.get_sha1(path)
109
117
 
110
118
 
111
119
    def file_class(self, filename):
130
138
        from osutils import appendpath, file_kind
131
139
        import os
132
140
 
133
 
        inv = self.inventory
 
141
        inv = self._inventory
134
142
 
135
143
        def descend(from_dir_relpath, from_dir_id, dp):
136
144
            ls = os.listdir(dp)
282
290
                    return pat
283
291
        else:
284
292
            return None
285
 
        
286
 
 
287
 
        
288
 
        
289
 
 
 
293
        
 
 
b'\\ No newline at end of file'