~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Martin Pool
  • Date: 2005-09-12 09:00:11 UTC
  • Revision ID: mbp@sourcefrog.net-20050912090011-97e81abfaeeb8948
- fix bug in Inventory.copy() 
  
  must copy inventory top-down so that directories are added before
  their children

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
# 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
 
 
 
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
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
 
 
63
 
41
64
    def __iter__(self):
42
65
        """Iterate through file_ids for this tree.
43
66
 
44
67
        file_ids are in a WorkingTree if they are in the working inventory
45
68
        and the working file exists.
46
69
        """
47
 
        self._update_statcache()
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
 
        self._update_statcache()
87
 
        if file_id in self._statcache:
88
 
            return True
89
 
        return os.path.exists(self.abspath(self.id2path(file_id)))
 
104
        path = inv.id2path(file_id)
 
105
        return os.path.exists(self.abspath(path))
90
106
 
91
107
 
92
108
    __contains__ = has_id
93
109
    
94
110
 
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
111
    def get_file_size(self, file_id):
101
 
        import os, stat
102
 
        return os.stat(self._get_store_filename(file_id))[stat.ST_SIZE]
 
112
        # is this still called?
 
113
        raise NotImplementedError()
103
114
 
104
115
 
105
116
    def get_file_sha1(self, file_id):
106
 
        import statcache
107
 
        self._update_statcache()
108
 
        return self._statcache[file_id][statcache.SC_SHA1]
 
117
        path = self._inventory.id2path(file_id)
 
118
        return self._hashcache.get_sha1(path)
109
119
 
110
120
 
111
121
    def file_class(self, filename):
127
137
 
128
138
        Skips the control directory.
129
139
        """
130
 
        from osutils import appendpath, file_kind
131
 
        import os
132
 
 
133
 
        inv = self.inventory
 
140
        inv = self._inventory
134
141
 
135
142
        def descend(from_dir_relpath, from_dir_id, dp):
136
143
            ls = os.listdir(dp)
197
204
        Currently returned depth-first, sorted by name within directories.
198
205
        """
199
206
        ## TODO: Work from given directory downwards
200
 
        from osutils import isdir, appendpath
201
 
        
202
207
        for path, dir_entry in self.inventory.directories():
203
208
            mutter("search for unknowns in %r" % path)
204
209
            dirabs = self.abspath(path)
261
266
        # Eventually it should be replaced with something more
262
267
        # accurate.
263
268
        
264
 
        import fnmatch
265
 
        from osutils import splitpath
266
 
        
267
269
        for pat in self.get_ignore_list():
268
270
            if '/' in pat or '\\' in pat:
269
271
                
283
285
        else:
284
286
            return None
285
287
        
286
 
 
287
 
        
288
 
        
289