« back to all changes in this revision
Viewing changes to bzrlib/tree.py
- browse files at revision 9
- compare with another revision
- download diff
- download tarball
- view history from revision 9
- Committer: mbp at sourcefrog
- Date: 2005-03-09 06:48:20 UTC
- Revision ID: mbp@sourcefrog.net-20050309064820-6e25df28956afa3c
doc
- files added:
- doc/roadmap.txt
- files removed:
- .bzrignore
- elementtree
- notes
- urlgrabber
- files renamed:
- bzrlib/commands.py => bzr.py
- files modified:
- README
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))
162
163
def has_id(self, file_id):
164
# files that have been deleted are excluded
165
if not self.inventory.has_id(file_id):
166
return False
167
return os.access(self.abspath(self.inventory.id2path(file_id)), os.F_OK)
154
return self._rel(self.id2path(file_id))
168
155
169
156
def get_file_size(self, file_id):
170
157
return os.stat(self._get_store_filename(file_id))[ST_SIZE]
183
170
return '?'
184
171
185
172
173
def file_kind(self, filename):
174
if isfile(self._rel(filename)):
175
return 'file'
176
elif isdir(self._rel(filename)):
177
return 'directory'
178
else:
179
return 'unknown'
180
181
186
182
def list_files(self):
187
183
"""Recursively list all files as (path, class, kind, id).
188
184
195
191
"""
196
192
inv = self.inventory
197
193
198
def descend(from_dir_relpath, from_dir_id, dp):
194
def descend(from_dir, from_dir_id, dp):
199
195
ls = os.listdir(dp)
200
196
ls.sort()
201
197
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
198
if bzrlib.BZRDIR == f:
206
199
continue
207
200
208
201
# path within tree
209
fp = appendpath(from_dir_relpath, f)
202
fp = appendpath(from_dir, f)
210
203
211
204
# absolute path
212
205
fap = appendpath(dp, f)
238
231
for ff in descend(fp, f_ie.file_id, fap):
239
232
yield ff
240
233
241
for f in descend('', inv.root.file_id, self.basedir):
234
for f in descend('', None, self.basedir):
242
235
yield f
243
236
244
237
245
238
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.
239
def unknowns(self, path='', dir_id=None):
240
"""Yield names of unknown files in this WorkingTree.
254
241
255
242
If there are any unknown directories then only the directory is
256
243
returned, not all its children. But if there are unknown files
258
245
259
246
Currently returned depth-first, sorted by name within directories.
260
247
"""
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
248
for fpath, fclass, fkind, fid in self.list_files():
249
if fclass == '?':
250
yield fpath
251
281
252
282
253
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
254
for fpath, fclass, fkind, fid in self.list_files():
255
if fclass == 'I':
256
yield fpath
288
257
289
258
290
259
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[:]
260
"""Return list of ignore patterns."""
299
261
if self.has_filename(bzrlib.IGNORE_FILENAME):
300
262
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
263
return [line.rstrip("\n\r") for line in f.readlines()]
264
else:
265
return bzrlib.DEFAULT_IGNORE
304
266
305
267
306
268
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
269
"""Check whether the filename matches an ignore pattern.
270
271
Patterns containing '/' need to match the whole path; others
272
match against only the last component."""
273
## TODO: Take them from a file, not hardcoded
274
## TODO: Use extended zsh-style globs maybe?
275
## TODO: Use '**' to match directories?
325
276
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
277
if '/' in pat:
278
if fnmatch.fnmatchcase(filename, pat):
279
return True
338
280
else:
339
281
if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
340
return pat
341
return None
282
return True
283
return False
342
284
343
285
344
286
349
291
350
292
File text can be retrieved from the text store.
351
293
352
TODO: Some kind of `__repr__` method, but a good one
294
:todo: Some kind of `__repr__` method, but a good one
353
295
probably means knowing the branch and revision number,
354
296
or at least passing a description to the constructor.
355
297
"""
362
304
ie = self._inventory[file_id]
363
305
f = self._store[ie.text_id]
364
306
mutter(" get fileid{%s} from %r" % (file_id, self))
307
fs = filesize(f)
308
if ie.text_size is None:
309
note("warning: no text size recorded on %r" % ie)
365
310
self._check_retrieved(ie, f)
366
311
return f
367
312
449
394
450
395
451
396
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