« back to all changes in this revision
Viewing changes to bzrlib/tree.py
- browse files at revision 48
- compare with another revision
- download diff
- download tarball
- view history from revision 48
- Committer: Martin Pool
- Date: 2005-03-15 05:19:54 UTC
- Revision ID: mbp@sourcefrog.net-20050315051954-e4bdd6dfd26f8ecf
witty comment
- files added:
- doc/roadmap.txt
- files removed:
- .rsyncexclude
- contrib
- contrib/bash
- contrib/zsh
- elementtree
- urlgrabber
- files modified:
- .bzrignore
added
removed
bzrlib/tree.py
1
# Copyright (C) 2005 Canonical Ltd
1
#! /usr/bin/env python
2
# -*- coding: UTF-8 -*-
2
3
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
20
21
from sets import Set
21
22
import os.path, os, fnmatch
22
23
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
28
24
from inventory import Inventory
29
25
from trace import mutter, note
26
from osutils import pumpfile, compare_files, filesize, quotefn, sha_file, \
27
joinpath, splitpath, appendpath, isdir, isfile, file_kind
30
28
from errors import bailout
31
29
import branch
30
from stat import S_ISREG, S_ISDIR, ST_MODE, ST_SIZE
32
31
33
32
import bzrlib
34
33
75
74
doc="Inventory of this Tree")
76
75
77
76
def _check_retrieved(self, ie, f):
78
fp = fingerprint_file(f)
79
f.seek(0)
80
81
if ie.text_size != None:
82
if ie.text_size != fp['size']:
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:
83
81
bailout("mismatched size for file %r in %r" % (ie.file_id, self._store),
84
82
["inventory expects %d bytes" % ie.text_size,
85
"file is actually %d bytes" % fp['size'],
83
"file is actually %d bytes" % fs,
86
84
"store is probably damaged/corrupt"])
87
85
88
if ie.text_sha1 != fp['sha1']:
86
f_hash = sha_file(f)
87
f.seek(0)
88
if ie.text_sha1 != f_hash:
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" % fp['sha1'],
91
"file is actually %s" % f_hash,
92
92
"store is probably damaged/corrupt"])
93
93
94
94
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):
95
def export(self, dest):
102
96
"""Export this tree to a new directory.
103
97
104
98
`dest` should not exist, and will be created holding the
105
99
contents of this tree.
106
100
107
TODO: To handle subdirectories we need to create the
101
:todo: To handle subdirectories we need to create the
108
102
directories first.
109
103
110
104
:note: If the export fails, the destination directory will be
121
115
elif kind == 'file':
122
116
pumpfile(self.get_file(ie.file_id), file(fullpath, 'wb'))
123
117
else:
124
bailout("don't know how to export {%s} of kind %r" % (fid, kind))
118
bailout("don't know how to export {%s} of kind %r", fid, kind)
125
119
mutter(" export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
126
120
127
121
144
138
return "<%s of %s>" % (self.__class__.__name__,
145
139
self.basedir)
146
140
147
def abspath(self, filename):
141
def _rel(self, filename):
148
142
return os.path.join(self.basedir, filename)
149
143
150
144
def has_filename(self, filename):
151
return os.path.exists(self.abspath(filename))
145
return os.path.exists(self._rel(filename))
152
146
153
147
def get_file(self, file_id):
154
148
return self.get_file_byname(self.id2path(file_id))
155
149
156
150
def get_file_byname(self, filename):
157
return file(self.abspath(filename), 'rb')
151
return file(self._rel(filename), 'rb')
158
152
159
153
def _get_store_filename(self, file_id):
160
## XXX: badly named; this isn't in the store at all
161
return self.abspath(self.id2path(file_id))
154
return self._rel(self.id2path(file_id))
162
155
163
156
def has_id(self, file_id):
164
157
# files that have been deleted are excluded
165
158
if not self.inventory.has_id(file_id):
166
159
return False
167
return os.access(self.abspath(self.inventory.id2path(file_id)), os.F_OK)
160
return os.access(self._rel(self.inventory.id2path(file_id)), os.F_OK)
168
161
169
162
def get_file_size(self, file_id):
170
163
return os.stat(self._get_store_filename(file_id))[ST_SIZE]
183
176
return '?'
184
177
185
178
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
186
188
def list_files(self):
187
189
"""Recursively list all files as (path, class, kind, id).
188
190
195
197
"""
196
198
inv = self.inventory
197
199
198
def descend(from_dir_relpath, from_dir_id, dp):
200
def descend(from_dir, from_dir_id, dp):
199
201
ls = os.listdir(dp)
200
202
ls.sort()
201
203
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.
205
204
if bzrlib.BZRDIR == f:
206
205
continue
207
206
208
207
# path within tree
209
fp = appendpath(from_dir_relpath, f)
208
fp = appendpath(from_dir, f)
210
209
211
210
# absolute path
212
211
fap = appendpath(dp, f)
238
237
for ff in descend(fp, f_ie.file_id, fap):
239
238
yield ff
240
239
241
for f in descend('', inv.root.file_id, self.basedir):
240
for f in descend('', None, self.basedir):
242
241
yield f
243
242
244
243
245
244
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.
245
def unknowns(self, path='', dir_id=None):
246
"""Yield names of unknown files in this WorkingTree.
254
247
255
248
If there are any unknown directories then only the directory is
256
249
returned, not all its children. But if there are unknown files
258
251
259
252
Currently returned depth-first, sorted by name within directories.
260
253
"""
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
254
for fpath, fclass, fkind, fid in self.list_files():
255
if fclass == '?':
256
yield fpath
257
281
258
282
259
def ignored_files(self):
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
260
for fpath, fclass, fkind, fid in self.list_files():
261
if fclass == 'I':
262
yield fpath
288
263
289
264
290
265
def get_ignore_list(self):
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[:]
266
"""Return list of ignore patterns."""
299
267
if self.has_filename(bzrlib.IGNORE_FILENAME):
300
268
f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
301
l.extend([line.rstrip("\n\r") for line in f.readlines()])
302
self._ignorelist = l
303
return l
269
return [line.rstrip("\n\r") for line in f.readlines()]
270
else:
271
return bzrlib.DEFAULT_IGNORE
304
272
305
273
306
274
def is_ignored(self, filename):
307
r"""Check whether the filename matches an ignore pattern.
308
309
Patterns containing '/' or '\' need to match the whole path;
310
others 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
317
# globbing stuff from cvs/rsync.
318
319
# XXX: fnmatch is actually not quite what we want: it's only
320
# approximately the same as real Unix fnmatch, and doesn't
321
# treat dotfiles correctly and allows * to match /.
322
# Eventually it should be replaced with something more
323
# accurate.
324
275
"""Check whether the filename matches an ignore pattern.
276
277
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?
325
282
for pat in self.get_ignore_list():
326
if '/' in pat or '\\' in pat:
327
328
# as a special case, you can put ./ at the start of a
329
# pattern; this is good to match in the top-level
330
# only;
331
332
if (pat[:2] == './') or (pat[:2] == '.\\'):
333
newpat = pat[2:]
334
else:
335
newpat = pat
336
if fnmatch.fnmatchcase(filename, newpat):
337
return pat
283
if '/' in pat:
284
if fnmatch.fnmatchcase(filename, pat):
285
return True
338
286
else:
339
287
if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
340
return pat
341
return None
288
return True
289
return False
342
290
343
291
344
292
349
297
350
298
File text can be retrieved from the text store.
351
299
352
TODO: Some kind of `__repr__` method, but a good one
300
:todo: Some kind of `__repr__` method, but a good one
353
301
probably means knowing the branch and revision number,
354
302
or at least passing a description to the constructor.
355
303
"""
362
310
ie = self._inventory[file_id]
363
311
f = self._store[ie.text_id]
364
312
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)
365
316
self._check_retrieved(ie, f)
366
317
return f
367
318
449
400
450
401
451
402
452
def find_renames(old_inv, new_inv):
453
for file_id in old_inv:
454
if file_id not in new_inv:
455
continue
456
old_name = old_inv.id2path(file_id)
457
new_name = new_inv.id2path(file_id)
458
if old_name != new_name:
459
yield (old_name, new_name)
460
Loggerhead is a web-based interface for Breezy
Version: 2.0.1