← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

  • Committer: mbp at sourcefrog
  • Date: 2005-04-09 06:36:40 UTC
  • Revision ID: mbp@sourcefrog.net-20050409063640-728d43dff50e91d8c09c83e3
update rsync exclude patterns

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
1
 
#! /usr/bin/env python
2
 
# -*- coding: UTF-8 -*-
 
1
# Copyright (C) 2005 Canonical Ltd
3
2
 
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
21
20
from sets import Set
22
21
import os.path, os, fnmatch
23
22
 
 
23
from osutils import pumpfile, compare_files, filesize, quotefn, sha_file, \
 
24
     joinpath, splitpath, appendpath, isdir, isfile, file_kind, fingerprint_file
 
25
import errno
 
26
from stat import S_ISREG, S_ISDIR, ST_MODE, ST_SIZE
 
27
 
24
28
from inventory import Inventory
25
29
from trace import mutter, note
26
 
from osutils import pumpfile, compare_files, filesize, quotefn, sha_file, \
27
 
     joinpath, splitpath, appendpath, isdir, isfile, file_kind
28
30
from errors import bailout
29
31
import branch
30
 
from stat import S_ISREG, S_ISDIR, ST_MODE, ST_SIZE
31
32
 
32
33
import bzrlib
33
34
 
74
75
                         doc="Inventory of this Tree")
75
76
 
76
77
    def _check_retrieved(self, ie, f):
77
 
        # TODO: Test this check by damaging the store?
78
 
        if ie.text_size is not None:
79
 
            fs = filesize(f)
80
 
            if fs != ie.text_size:
 
78
        fp = fingerprint_file(f)
 
79
        f.seek(0)
 
80
        
 
81
        if ie.text_size != None:
 
82
            if ie.text_size != fp['size']:
81
83
                bailout("mismatched size for file %r in %r" % (ie.file_id, self._store),
82
84
                        ["inventory expects %d bytes" % ie.text_size,
83
 
                         "file is actually %d bytes" % fs,
 
85
                         "file is actually %d bytes" % fp['size'],
84
86
                         "store is probably damaged/corrupt"])
85
87
 
86
 
        f_hash = sha_file(f)
87
 
        f.seek(0)
88
 
        if ie.text_sha1 != f_hash:
 
88
        if ie.text_sha1 != fp['sha1']:
89
89
            bailout("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
90
90
                    ["inventory expects %s" % ie.text_sha1,
91
 
                     "file is actually %s" % f_hash,
 
91
                     "file is actually %s" % fp['sha1'],
92
92
                     "store is probably damaged/corrupt"])
93
93
 
94
94
 
95
 
    def export(self, dest):
 
95
    def print_file(self, fileid):
 
96
        """Print file with id `fileid` to stdout."""
 
97
        import sys
 
98
        pumpfile(self.get_file(fileid), sys.stdout)
 
99
        
 
100
        
 
101
    def export(self, dest):        
96
102
        """Export this tree to a new directory.
97
103
 
98
104
        `dest` should not exist, and will be created holding the
115
121
            elif kind == 'file':
116
122
                pumpfile(self.get_file(ie.file_id), file(fullpath, 'wb'))
117
123
            else:
118
 
                bailout("don't know how to export {%s} of kind %r", fid, kind)
 
124
                bailout("don't know how to export {%s} of kind %r" % (fid, kind))
119
125
            mutter("  export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
120
126
 
121
127
 
138
144
        return "<%s of %s>" % (self.__class__.__name__,
139
145
                               self.basedir)
140
146
 
141
 
    def _rel(self, filename):
 
147
    def abspath(self, filename):
142
148
        return os.path.join(self.basedir, filename)
143
149
 
144
150
    def has_filename(self, filename):
145
 
        return os.path.exists(self._rel(filename))
 
151
        return os.path.exists(self.abspath(filename))
146
152
 
147
153
    def get_file(self, file_id):
148
154
        return self.get_file_byname(self.id2path(file_id))
149
155
 
150
156
    def get_file_byname(self, filename):
151
 
        return file(self._rel(filename), 'rb')
 
157
        return file(self.abspath(filename), 'rb')
152
158
 
153
159
    def _get_store_filename(self, file_id):
154
 
        return self._rel(self.id2path(file_id))
 
160
        ## XXX: badly named; this isn't in the store at all
 
161
        return self.abspath(self.id2path(file_id))
155
162
 
156
163
    def has_id(self, file_id):
157
164
        # files that have been deleted are excluded
158
165
        if not self.inventory.has_id(file_id):
159
166
            return False
160
 
        return os.access(self._rel(self.inventory.id2path(file_id)), os.F_OK)
 
167
        return os.access(self.abspath(self.inventory.id2path(file_id)), os.F_OK)
161
168
 
162
169
    def get_file_size(self, file_id):
163
170
        return os.stat(self._get_store_filename(file_id))[ST_SIZE]
176
183
            return '?'
177
184
 
178
185
 
179
 
    def file_kind(self, filename):
180
 
        if isfile(self._rel(filename)):
181
 
            return 'file'
182
 
        elif isdir(self._rel(filename)):
183
 
            return 'directory'
184
 
        else:
185
 
            return 'unknown'
186
 
 
187
 
 
188
186
    def list_files(self):
189
187
        """Recursively list all files as (path, class, kind, id).
190
188
 
197
195
        """
198
196
        inv = self.inventory
199
197
 
200
 
        def descend(from_dir, from_dir_id, dp):
 
198
        def descend(from_dir_relpath, from_dir_id, dp):
201
199
            ls = os.listdir(dp)
202
200
            ls.sort()
203
201
            for f in ls:
 
202
                ## TODO: If we find a subdirectory with its own .bzr
 
203
                ## directory, then that is a separate tree and we
 
204
                ## should exclude it.
204
205
                if bzrlib.BZRDIR == f:
205
206
                    continue
206
207
 
207
208
                # path within tree
208
 
                fp = appendpath(from_dir, f)
 
209
                fp = appendpath(from_dir_relpath, f)
209
210
 
210
211
                # absolute path
211
212
                fap = appendpath(dp, f)
237
238
                for ff in descend(fp, f_ie.file_id, fap):
238
239
                    yield ff
239
240
 
240
 
        for f in descend('', None, self.basedir):
 
241
        for f in descend('', inv.root.file_id, self.basedir):
241
242
            yield f
242
243
            
243
244
 
244
245
 
245
 
    def unknowns(self, path='', dir_id=None):
246
 
        """Yield names of unknown files in this WorkingTree.
 
246
    def unknowns(self):
 
247
        for subp in self.extras():
 
248
            if not self.is_ignored(subp):
 
249
                yield subp
 
250
 
 
251
 
 
252
    def extras(self):
 
253
        """Yield all unknown files in this WorkingTree.
247
254
 
248
255
        If there are any unknown directories then only the directory is
249
256
        returned, not all its children.  But if there are unknown files
251
258
 
252
259
        Currently returned depth-first, sorted by name within directories.
253
260
        """
254
 
        for fpath, fclass, fkind, fid in self.list_files():
255
 
            if fclass == '?':
256
 
                yield fpath
257
 
                
 
261
        ## TODO: Work from given directory downwards
 
262
        
 
263
        for path, dir_entry in self.inventory.directories():
 
264
            mutter("search for unknowns in %r" % path)
 
265
            dirabs = self.abspath(path)
 
266
            if not isdir(dirabs):
 
267
                # e.g. directory deleted
 
268
                continue
 
269
 
 
270
            fl = []
 
271
            for subf in os.listdir(dirabs):
 
272
                if (subf != '.bzr'
 
273
                    and (subf not in dir_entry.children)):
 
274
                    fl.append(subf)
 
275
            
 
276
            fl.sort()
 
277
            for subf in fl:
 
278
                subp = appendpath(path, subf)
 
279
                yield subp
 
280
 
258
281
 
259
282
    def ignored_files(self):
260
 
        for fpath, fclass, fkind, fid in self.list_files():
261
 
            if fclass == 'I':
262
 
                yield fpath
 
283
        """Yield list of PATH, IGNORE_PATTERN"""
 
284
        for subp in self.extras():
 
285
            pat = self.is_ignored(subp)
 
286
            if pat != None:
 
287
                yield subp, pat
263
288
 
264
289
 
265
290
    def get_ignore_list(self):
266
 
        """Return list of ignore patterns."""
 
291
        """Return list of ignore patterns.
 
292
 
 
293
        Cached in the Tree object after the first call.
 
294
        """
 
295
        if hasattr(self, '_ignorelist'):
 
296
            return self._ignorelist
 
297
 
 
298
        l = bzrlib.DEFAULT_IGNORE[:]
267
299
        if self.has_filename(bzrlib.IGNORE_FILENAME):
268
300
            f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
269
 
            return [line.rstrip("\n\r") for line in f.readlines()]
270
 
        else:
271
 
            return bzrlib.DEFAULT_IGNORE
 
301
            l.extend([line.rstrip("\n\r") for line in f.readlines()])
 
302
        self._ignorelist = l
 
303
        return l
272
304
 
273
305
 
274
306
    def is_ignored(self, filename):
275
307
        """Check whether the filename matches an ignore pattern.
276
308
 
277
309
        Patterns containing '/' need to match the whole path; others
278
 
        match against only the last component."""
279
 
        ## TODO: Take them from a file, not hardcoded
280
 
        ## TODO: Use extended zsh-style globs maybe?
281
 
        ## TODO: Use '**' to match directories?
 
310
        match against only the last component.
 
311
 
 
312
        If the file is ignored, returns the pattern which caused it to
 
313
        be ignored, otherwise None.  So this can simply be used as a
 
314
        boolean if desired."""
 
315
 
 
316
        ## TODO: Use '**' to match directories, and other extended globbing stuff from cvs/rsync.
 
317
        
282
318
        for pat in self.get_ignore_list():
283
319
            if '/' in pat:
284
 
                if fnmatch.fnmatchcase(filename, pat):
285
 
                    return True
 
320
                # as a special case, you can put ./ at the start of a pattern;
 
321
                # this is good to match in the top-level only;
 
322
                if pat[:2] == './':
 
323
                    newpat = pat[2:]
 
324
                else:
 
325
                    newpat = pat
 
326
                if fnmatch.fnmatchcase(filename, newpat):
 
327
                    return pat
286
328
            else:
287
329
                if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
288
 
                    return True
289
 
        return False
 
330
                    return pat
 
331
        return None
290
332
        
291
333
 
292
334
        
310
352
        ie = self._inventory[file_id]
311
353
        f = self._store[ie.text_id]
312
354
        mutter("  get fileid{%s} from %r" % (file_id, self))
313
 
        fs = filesize(f)
314
 
        if ie.text_size is None:
315
 
            note("warning: no text size recorded on %r" % ie)
316
355
        self._check_retrieved(ie, f)
317
356
        return f
318
357
 
400
439
 
401
440
    
402
441
 
 
442
def find_renames(old_inv, new_inv):
 
443
    for file_id in old_inv:
 
444
        if file_id not in new_inv:
 
445
            continue
 
446
        old_name = old_inv.id2path(file_id)
 
447
        new_name = new_inv.id2path(file_id)
 
448
        if old_name != new_name:
 
449
            yield (old_name, new_name)
 
450