← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Robert Collins
  • Date: 2005-08-23 06:52:09 UTC
  • mto: (974.1.50) (1185.1.10) (1092.3.1)
  • mto: This revision was merged to the branch mainline in revision 1139.
  • Revision ID: robertc@robertcollins.net-20050823065209-81cd5962c401751b
move io redirection into each test case from the global runner

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
    
20
25
import bzrlib.tree
21
26
from errors import BzrCheckError
22
27
from trace import mutter
23
 
import statcache
24
28
 
25
29
class WorkingTree(bzrlib.tree.Tree):
26
30
    """Working copy tree.
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
 
        self._update_statcache()
 
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
 
41
61
 
42
62
    def __iter__(self):
43
63
        """Iterate through file_ids for this tree.
46
66
        and the working file exists.
47
67
        """
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
 
        if file_id in self._statcache:
87
 
            return True
88
 
        return os.path.exists(self.abspath(self.id2path(file_id)))
 
102
        path = inv.id2path(file_id)
 
103
        return os.path.exists(self.abspath(path))
89
104
 
90
105
 
91
106
    __contains__ = has_id
92
107
    
93
108
 
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
109
    def get_file_size(self, file_id):
100
 
        import os, stat
101
 
        return os.stat(self._get_store_filename(file_id))[stat.ST_SIZE]
 
110
        # is this still called?
 
111
        raise NotImplementedError()
102
112
 
103
113
 
104
114
    def get_file_sha1(self, file_id):
105
 
        return self._statcache[file_id][statcache.SC_SHA1]
 
115
        path = self._inventory.id2path(file_id)
 
116
        return self._hashcache.get_sha1(path)
106
117
 
107
118
 
108
119
    def file_class(self, filename):
127
138
        from osutils import appendpath, file_kind
128
139
        import os
129
140
 
130
 
        inv = self.inventory
 
141
        inv = self._inventory
131
142
 
132
143
        def descend(from_dir_relpath, from_dir_id, dp):
133
144
            ls = os.listdir(dp)
279
290
                    return pat
280
291
        else:
281
292
            return None
282
 
        
283
 
 
284
 
        
285
 
        
286
 
 
 
293
        
 
 
b'\\ No newline at end of file'