1
# Copyright (C) 2005 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""Tree classes, representing directory at point in time.
21
import os.path, os, fnmatch
23
from osutils import pumpfile, compare_files, filesize, quotefn, sha_file, \
24
joinpath, splitpath, appendpath, isdir, isfile, file_kind, fingerprint_file
26
from stat import S_ISREG, S_ISDIR, ST_MODE, ST_SIZE
28
from inventory import Inventory
29
from trace import mutter, note
30
from errors import bailout
36
"""Abstract file tree.
38
There are several subclasses:
40
* `WorkingTree` exists as files on disk editable by the user.
42
* `RevisionTree` is a tree as recorded at some point in the past.
46
Trees contain an `Inventory` object, and also know how to retrieve
47
file texts mentioned in the inventory, either from a working
48
directory or from a store.
50
It is possible for trees to contain files that are not described
51
in their inventory or vice versa; for this use `filenames()`.
53
Trees can be compared, etc, regardless of whether they are working
54
trees or versioned trees.
57
def has_filename(self, filename):
58
"""True if the tree has given filename."""
59
raise NotImplementedError()
61
def has_id(self, file_id):
62
return self.inventory.has_id(file_id)
65
"""Return set of all ids in this tree."""
66
return self.inventory.id_set()
68
def id2path(self, file_id):
69
return self.inventory.id2path(file_id)
71
def _get_inventory(self):
72
return self._inventory
74
inventory = property(_get_inventory,
75
doc="Inventory of this Tree")
77
def _check_retrieved(self, ie, f):
78
fp = fingerprint_file(f)
81
if ie.text_size != None:
82
if ie.text_size != fp['size']:
83
bailout("mismatched size for file %r in %r" % (ie.file_id, self._store),
84
["inventory expects %d bytes" % ie.text_size,
85
"file is actually %d bytes" % fp['size'],
86
"store is probably damaged/corrupt"])
88
if ie.text_sha1 != fp['sha1']:
89
bailout("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
90
["inventory expects %s" % ie.text_sha1,
91
"file is actually %s" % fp['sha1'],
92
"store is probably damaged/corrupt"])
95
def print_file(self, fileid):
96
"""Print file with id `fileid` to stdout."""
98
pumpfile(self.get_file(fileid), sys.stdout)
101
def export(self, dest):
102
"""Export this tree to a new directory.
104
`dest` should not exist, and will be created holding the
105
contents of this tree.
107
TODO: To handle subdirectories we need to create the
110
:note: If the export fails, the destination directory will be
111
left in a half-assed state.
114
mutter('export version %r' % self)
116
for dp, ie in inv.iter_entries():
118
fullpath = appendpath(dest, dp)
119
if kind == 'directory':
122
pumpfile(self.get_file(ie.file_id), file(fullpath, 'wb'))
124
bailout("don't know how to export {%s} of kind %r" % (fid, kind))
125
mutter(" export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
129
class WorkingTree(Tree):
130
"""Working copy tree.
132
The inventory is held in the `Branch` working-inventory, and the
133
files are in a directory on disk.
135
It is possible for a `WorkingTree` to have a filename which is
136
not listed in the Inventory and vice versa.
138
def __init__(self, basedir, inv):
139
self._inventory = inv
140
self.basedir = basedir
141
self.path2id = inv.path2id
144
return "<%s of %s>" % (self.__class__.__name__,
147
def abspath(self, filename):
148
return os.path.join(self.basedir, filename)
150
def has_filename(self, filename):
151
return os.path.exists(self.abspath(filename))
153
def get_file(self, file_id):
154
return self.get_file_byname(self.id2path(file_id))
156
def get_file_byname(self, filename):
157
return file(self.abspath(filename), 'rb')
159
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))
163
def has_id(self, file_id):
164
# files that have been deleted are excluded
165
if not self.inventory.has_id(file_id):
167
return os.access(self.abspath(self.inventory.id2path(file_id)), os.F_OK)
169
def get_file_size(self, file_id):
170
return os.stat(self._get_store_filename(file_id))[ST_SIZE]
172
def get_file_sha1(self, file_id):
173
f = self.get_file(file_id)
177
def file_class(self, filename):
178
if self.path2id(filename):
180
elif self.is_ignored(filename):
186
def list_files(self):
187
"""Recursively list all files as (path, class, kind, id).
189
Lists, but does not descend into unversioned directories.
191
This does not include files that have been deleted in this
194
Skips the control directory.
198
def descend(from_dir_relpath, from_dir_id, dp):
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
if bzrlib.BZRDIR == f:
209
fp = appendpath(from_dir_relpath, f)
212
fap = appendpath(dp, f)
214
f_ie = inv.get_child(from_dir_id, f)
217
elif self.is_ignored(fp):
226
bailout("file %r entered as kind %r id %r, now of kind %r"
227
% (fap, f_ie.kind, f_ie.file_id, fk))
229
yield fp, c, fk, (f_ie and f_ie.file_id)
231
if fk != 'directory':
235
# don't descend unversioned directories
238
for ff in descend(fp, f_ie.file_id, fap):
241
for f in descend('', inv.root.file_id, self.basedir):
247
for subp in self.extras():
248
if not self.is_ignored(subp):
253
"""Yield all unknown files in this WorkingTree.
255
If there are any unknown directories then only the directory is
256
returned, not all its children. But if there are unknown files
257
under a versioned subdirectory, they are returned.
259
Currently returned depth-first, sorted by name within directories.
261
## TODO: Work from given directory downwards
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
271
for subf in os.listdir(dirabs):
273
and (subf not in dir_entry.children)):
278
subp = appendpath(path, subf)
282
def ignored_files(self):
283
"""Yield list of PATH, IGNORE_PATTERN"""
284
for subp in self.extras():
285
pat = self.is_ignored(subp)
290
def get_ignore_list(self):
291
"""Return list of ignore patterns.
293
Cached in the Tree object after the first call.
295
if hasattr(self, '_ignorelist'):
296
return self._ignorelist
298
l = bzrlib.DEFAULT_IGNORE[:]
299
if self.has_filename(bzrlib.IGNORE_FILENAME):
300
f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
301
l.extend([line.rstrip("\n\r") for line in f.readlines()])
306
def is_ignored(self, filename):
307
"""Check whether the filename matches an ignore pattern.
309
Patterns containing '/' need to match the whole path; others
310
match against only the last component.
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."""
316
## TODO: Use '**' to match directories, and other extended globbing stuff from cvs/rsync.
318
for pat in self.get_ignore_list():
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;
326
if fnmatch.fnmatchcase(filename, newpat):
329
if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
337
class RevisionTree(Tree):
338
"""Tree viewing a previous revision.
340
File text can be retrieved from the text store.
342
TODO: Some kind of `__repr__` method, but a good one
343
probably means knowing the branch and revision number,
344
or at least passing a description to the constructor.
347
def __init__(self, store, inv):
349
self._inventory = inv
351
def get_file(self, file_id):
352
ie = self._inventory[file_id]
353
f = self._store[ie.text_id]
354
mutter(" get fileid{%s} from %r" % (file_id, self))
355
self._check_retrieved(ie, f)
358
def get_file_size(self, file_id):
359
return self._inventory[file_id].text_size
361
def get_file_sha1(self, file_id):
362
ie = self._inventory[file_id]
365
def has_filename(self, filename):
366
return bool(self.inventory.path2id(filename))
368
def list_files(self):
369
# The only files returned by this are those from the version
370
for path, entry in self.inventory.iter_entries():
371
yield path, 'V', entry.kind, entry.file_id
374
class EmptyTree(Tree):
376
self._inventory = Inventory()
378
def has_filename(self, filename):
381
def list_files(self):
382
if False: # just to make it a generator
387
######################################################################
390
# TODO: Merge these two functions into a single one that can operate
391
# on either a whole tree or a set of files.
393
# TODO: Return the diff in order by filename, not by category or in
394
# random order. Can probably be done by lock-stepping through the
395
# filenames from both trees.
398
def file_status(filename, old_tree, new_tree):
399
"""Return single-letter status, old and new names for a file.
401
The complexity here is in deciding how to represent renames;
402
many complex cases are possible.
404
old_inv = old_tree.inventory
405
new_inv = new_tree.inventory
406
new_id = new_inv.path2id(filename)
407
old_id = old_inv.path2id(filename)
409
if not new_id and not old_id:
410
# easy: doesn't exist in either; not versioned at all
411
if new_tree.is_ignored(filename):
412
return 'I', None, None
414
return '?', None, None
416
# There is now a file of this name, great.
419
# There is no longer a file of this name, but we can describe
420
# what happened to the file that used to have
421
# this name. There are two possibilities: either it was
422
# deleted entirely, or renamed.
424
if new_inv.has_id(old_id):
425
return 'X', old_inv.id2path(old_id), new_inv.id2path(old_id)
427
return 'D', old_inv.id2path(old_id), None
429
# if the file_id is new in this revision, it is added
430
if new_id and not old_inv.has_id(new_id):
433
# if there used to be a file of this name, but that ID has now
434
# disappeared, it is deleted
435
if old_id and not new_inv.has_id(old_id):
442
def find_renames(old_inv, new_inv):
443
for file_id in old_inv:
444
if file_id not in new_inv:
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)
added
removed
bzrlib/tree.py
