« back to all changes in this revision
Viewing changes to bzrlib/inventory.py
- browse files at revision 1216
- compare with another revision
- download diff
- download tarball
- view history from revision 1216
- Committer: Martin Pool
- Date: 2005-09-12 09:50:44 UTC
- Revision ID: mbp@sourcefrog.net-20050912095044-6acfdb5611729987
- no tests in bzrlib.fetch anymore
- files added:
- .rsyncexclude
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- patches
- tools
- files removed:
- bzrlib/tests.py
- files renamed:
- bzr.py => bzrlib/commands.py
- files modified:
- .bzrignore
added
removed
bzrlib/inventory.py
1
#! /usr/bin/env python
2
# -*- coding: UTF-8 -*-
1
# (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
15
14
# along with this program; if not, write to the Free Software
16
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
16
18
"""Inventories map files to their name in a revision."""
19
20
21
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
22
__author__ = "Martin Pool <mbp@canonical.com>"
23
24
import sys, os.path, types
25
from sets import Set
26
27
try:
28
from cElementTree import Element, ElementTree, SubElement
29
except ImportError:
30
from elementtree.ElementTree import Element, ElementTree, SubElement
31
32
from xml import XMLMixin
33
from errors import bailout
34
from osutils import uuid, quotefn, splitpath, joinpath, appendpath
35
from trace import mutter
36
37
class InventoryEntry(XMLMixin):
17
18
# TODO: Maybe also keep the full path of the entry, and the children?
19
# But those depend on its position within a particular inventory, and
20
# it would be nice not to need to hold the backpointer here.
21
22
# TODO: Perhaps split InventoryEntry into subclasses for files,
23
# directories, etc etc.
24
25
26
# This should really be an id randomly assigned when the tree is
27
# created, but it's not for now.
28
ROOT_ID = "TREE_ROOT"
29
30
31
import sys, os.path, types, re
32
33
import bzrlib
34
from bzrlib.errors import BzrError, BzrCheckError
35
36
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
37
from bzrlib.trace import mutter
38
from bzrlib.errors import NotVersionedError
39
40
41
class InventoryEntry(object):
38
42
"""Description of a versioned file.
39
43
40
44
An InventoryEntry has the following fields, which are also
41
45
present in the XML inventory-entry element:
42
46
43
* *file_id*
44
* *name*: (only the basename within the directory, must not
45
contain slashes)
46
* *kind*: "directory" or "file"
47
* *directory_id*: (if absent/null means the branch root directory)
48
* *text_sha1*: only for files
49
* *text_size*: in bytes, only for files
50
* *text_id*: identifier for the text version, only for files
51
52
InventoryEntries can also exist inside a WorkingTree
53
inventory, in which case they are not yet bound to a
54
particular revision of the file. In that case the text_sha1,
55
text_size and text_id are absent.
56
47
file_id
48
49
name
50
(within the parent directory)
51
52
kind
53
'directory' or 'file'
54
55
parent_id
56
file_id of the parent directory, or ROOT_ID
57
58
entry_version
59
the revision_id in which the name or parent of this file was
60
last changed
61
62
text_sha1
63
sha-1 of the text of the file
64
65
text_size
66
size in bytes of the text of the file
67
68
text_version
69
the revision_id in which the text of this file was introduced
70
71
(reading a version 4 tree created a text_id field.)
57
72
58
73
>>> i = Inventory()
59
74
>>> i.path2id('')
60
>>> i.add(InventoryEntry('123', 'src', kind='directory'))
61
>>> i.add(InventoryEntry('2323', 'hello.c', parent_id='123'))
75
'TREE_ROOT'
76
>>> i.add(InventoryEntry('123', 'src', 'directory', ROOT_ID))
77
InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT')
78
>>> i.add(InventoryEntry('2323', 'hello.c', 'file', parent_id='123'))
79
InventoryEntry('2323', 'hello.c', kind='file', parent_id='123')
62
80
>>> for j in i.iter_entries():
63
81
... print j
64
82
...
65
('src', InventoryEntry('123', 'src', kind='directory', parent_id=None))
83
('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
66
84
('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
67
>>> i.add(InventoryEntry('2323', 'bye.c', parent_id='123'))
85
>>> i.add(InventoryEntry('2323', 'bye.c', 'file', '123'))
68
86
Traceback (most recent call last):
69
87
...
70
BzrError: ('inventory already contains entry with id {2323}', [])
71
>>> i.add(InventoryEntry('2324', 'bye.c', parent_id='123'))
72
>>> i.add(InventoryEntry('2325', 'wibble', parent_id='123', kind='directory'))
88
BzrError: inventory already contains entry with id {2323}
89
>>> i.add(InventoryEntry('2324', 'bye.c', 'file', '123'))
90
InventoryEntry('2324', 'bye.c', kind='file', parent_id='123')
91
>>> i.add(InventoryEntry('2325', 'wibble', 'directory', '123'))
92
InventoryEntry('2325', 'wibble', kind='directory', parent_id='123')
73
93
>>> i.path2id('src/wibble')
74
94
'2325'
75
95
>>> '2325' in i
76
96
True
77
>>> i.add(InventoryEntry('2326', 'wibble.c', parent_id='2325'))
97
>>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
98
InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
78
99
>>> i['2326']
79
100
InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
80
101
>>> for j in i.iter_entries():
88
109
src/wibble/wibble.c
89
110
>>> i.id2path('2326')
90
111
'src/wibble/wibble.c'
91
92
:todo: Maybe also keep the full path of the entry, and the children?
93
But those depend on its position within a particular inventory, and
94
it would be nice not to need to hold the backpointer here.
95
112
"""
96
def __init__(self, file_id, name, kind='file', text_id=None,
97
parent_id=None):
113
114
__slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
115
'text_id', 'parent_id', 'children',
116
'text_version', 'entry_version', ]
117
118
119
def __init__(self, file_id, name, kind, parent_id, text_id=None):
98
120
"""Create an InventoryEntry
99
121
100
122
The filename must be a single component, relative to the
101
123
parent directory; it cannot be a whole path or relative name.
102
124
103
>>> e = InventoryEntry('123', 'hello.c')
125
>>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
104
126
>>> e.name
105
127
'hello.c'
106
128
>>> e.file_id
107
129
'123'
108
>>> e = InventoryEntry('123', 'src/hello.c')
130
>>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
109
131
Traceback (most recent call last):
110
BzrError: ("InventoryEntry name is not a simple filename: 'src/hello.c'", [])
132
BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
111
133
"""
112
113
if len(splitpath(name)) != 1:
114
bailout('InventoryEntry name is not a simple filename: %r'
115
% name)
116
134
assert isinstance(name, basestring), name
135
if '/' in name or '\\' in name:
136
raise BzrCheckError('InventoryEntry name %r is invalid' % name)
137
138
self.text_version = None
139
self.entry_version = None
140
self.text_sha1 = None
141
self.text_size = None
117
142
self.file_id = file_id
118
143
self.name = name
119
assert kind in ['file', 'directory']
120
144
self.kind = kind
121
145
self.text_id = text_id
122
146
self.parent_id = parent_id
123
self.text_sha1 = None
124
self.text_size = None
147
if kind == 'directory':
148
self.children = {}
149
elif kind == 'file':
150
pass
151
else:
152
raise BzrError("unhandled entry kind %r" % kind)
153
154
155
156
def sorted_children(self):
157
l = self.children.items()
158
l.sort()
159
return l
125
160
126
161
127
162
def copy(self):
128
163
other = InventoryEntry(self.file_id, self.name, self.kind,
129
self.text_id, self.parent_id)
164
self.parent_id)
165
other.text_id = self.text_id
130
166
other.text_sha1 = self.text_sha1
131
167
other.text_size = self.text_size
168
other.text_version = self.text_version
169
# note that children are *not* copied; they're pulled across when
170
# others are added
132
171
return other
133
172
134
173
141
180
self.parent_id))
142
181
143
182
144
def to_element(self):
145
"""Convert to XML element"""
146
e = Element('entry')
147
148
e.set('name', self.name)
149
e.set('file_id', self.file_id)
150
e.set('kind', self.kind)
151
152
if self.text_size is not None:
153
e.set('text_size', '%d' % self.text_size)
154
155
for f in ['text_id', 'text_sha1', 'parent_id']:
156
v = getattr(self, f)
157
if v is not None:
158
e.set(f, v)
159
160
e.tail = '\n'
161
162
return e
163
164
165
def from_element(cls, elt):
166
assert elt.tag == 'entry'
167
self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'))
168
self.text_id = elt.get('text_id')
169
self.text_sha1 = elt.get('text_sha1')
170
self.parent_id = elt.get('parent_id')
171
172
## mutter("read inventoryentry: %r" % (elt.attrib))
173
174
v = elt.get('text_size')
175
self.text_size = v and int(v)
176
177
return self
178
179
180
from_element = classmethod(from_element)
181
182
def __cmp__(self, other):
183
if self is other:
184
return 0
183
def __eq__(self, other):
185
184
if not isinstance(other, InventoryEntry):
186
185
return NotImplemented
187
186
188
return cmp(self.file_id, other.file_id) \
189
or cmp(self.name, other.name) \
190
or cmp(self.text_sha1, other.text_sha1) \
191
or cmp(self.text_size, other.text_size) \
192
or cmp(self.text_id, other.text_id) \
193
or cmp(self.parent_id, other.parent_id) \
194
or cmp(self.kind, other.kind)
195
196
197
198
class Inventory(XMLMixin):
187
return (self.file_id == other.file_id) \
188
and (self.name == other.name) \
189
and (self.text_sha1 == other.text_sha1) \
190
and (self.text_size == other.text_size) \
191
and (self.text_id == other.text_id) \
192
and (self.parent_id == other.parent_id) \
193
and (self.kind == other.kind) \
194
and (self.text_version == other.text_version) \
195
and (self.entry_version == other.entry_version)
196
197
198
def __ne__(self, other):
199
return not (self == other)
200
201
def __hash__(self):
202
raise ValueError('not hashable')
203
204
205
206
class RootEntry(InventoryEntry):
207
def __init__(self, file_id):
208
self.file_id = file_id
209
self.children = {}
210
self.kind = 'root_directory'
211
self.parent_id = None
212
self.name = ''
213
214
def __eq__(self, other):
215
if not isinstance(other, RootEntry):
216
return NotImplemented
217
218
return (self.file_id == other.file_id) \
219
and (self.children == other.children)
220
221
222
223
class Inventory(object):
199
224
"""Inventory of versioned files in a tree.
200
225
201
An Inventory acts like a set of InventoryEntry items. You can
202
also look files up by their file_id or name.
203
204
May be read from and written to a metadata file in a tree. To
205
manipulate the inventory (for example to add a file), it is read
206
in, modified, and then written back out.
226
This describes which file_id is present at each point in the tree,
227
and possibly the SHA-1 or other information about the file.
228
Entries can be looked up either by path or by file_id.
207
229
208
230
The inventory represents a typical unix file tree, with
209
231
directories containing files and subdirectories. We never store
213
235
returned quickly.
214
236
215
237
InventoryEntry objects must not be modified after they are
216
inserted.
238
inserted, other than through the Inventory API.
217
239
218
240
>>> inv = Inventory()
219
>>> inv.write_xml(sys.stdout)
220
<inventory>
221
</inventory>
222
>>> inv.add(InventoryEntry('123-123', 'hello.c'))
241
>>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
242
InventoryEntry('123-123', 'hello.c', kind='file', parent_id='TREE_ROOT')
223
243
>>> inv['123-123'].name
224
244
'hello.c'
225
>>> for file_id in inv: print file_id
226
...
227
123-123
228
245
229
246
May be treated as an iterator or set to look up file ids:
230
247
237
254
238
255
>>> [x[0] for x in inv.iter_entries()]
239
256
['hello.c']
240
241
>>> inv.write_xml(sys.stdout)
242
<inventory>
243
<entry file_id="123-123" kind="file" name="hello.c" />
244
</inventory>
245
257
>>> inv = Inventory('TREE_ROOT-12345678-12345678')
258
>>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
259
InventoryEntry('123-123', 'hello.c', kind='file', parent_id='TREE_ROOT-12345678-12345678')
246
260
"""
247
248
## TODO: Clear up handling of files in subdirectories; we probably
249
## do want to be able to just look them up by name but this
250
## probably means gradually walking down the path, looking up as we go.
251
252
## TODO: Make sure only canonical filenames are stored.
253
254
## TODO: Do something sensible about the possible collisions on
255
## case-losing filesystems. Perhaps we should just always forbid
256
## such collisions.
257
258
## _tree should probably just be stored as
259
## InventoryEntry._children on each directory.
260
261
def __init__(self):
261
def __init__(self, root_id=ROOT_ID):
262
262
"""Create or read an inventory.
263
263
264
264
If a working directory is specified, the inventory is read
265
265
from there. If the file is specified, read from that. If not,
266
266
the inventory is created empty.
267
268
The inventory is created with a default root directory, with
269
an id of None.
267
270
"""
268
self._byid = dict()
269
270
# _tree is indexed by parent_id; at each level a map from name
271
# to ie. The None entry is the root.
272
self._tree = {None: {}}
271
# We are letting Branch(init=True) create a unique inventory
272
# root id. Rather than generating a random one here.
273
#if root_id is None:
274
# root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
275
self.root = RootEntry(root_id)
276
self._byid = {self.root.file_id: self.root}
277
278
279
def copy(self):
280
other = Inventory(self.root.file_id)
281
# copy recursively so we know directories will be added before
282
# their children. There are more efficient ways than this...
283
for path, entry in self.iter_entries():
284
if entry == self.root:
285
continue
286
other.add(entry.copy())
287
return other
273
288
274
289
275
290
def __iter__(self):
281
296
return len(self._byid)
282
297
283
298
284
def iter_entries(self, parent_id=None):
299
def iter_entries(self, from_dir=None):
285
300
"""Return (path, entry) pairs, in order by name."""
286
kids = self._tree[parent_id].items()
301
if from_dir == None:
302
assert self.root
303
from_dir = self.root
304
elif isinstance(from_dir, basestring):
305
from_dir = self._byid[from_dir]
306
307
kids = from_dir.children.items()
287
308
kids.sort()
288
309
for name, ie in kids:
289
310
yield name, ie
290
311
if ie.kind == 'directory':
291
for cn, cie in self.iter_entries(parent_id=ie.file_id):
292
yield joinpath([name, cn]), cie
293
294
295
def directories(self, include_root=True):
296
"""Return (path, entry) pairs for all directories.
297
"""
298
if include_root:
299
yield '', None
300
for path, entry in self.iter_entries():
301
if entry.kind == 'directory':
302
yield path, entry
312
for cn, cie in self.iter_entries(from_dir=ie.file_id):
313
yield os.path.join(name, cn), cie
314
315
316
def entries(self):
317
"""Return list of (path, ie) for all entries except the root.
318
319
This may be faster than iter_entries.
320
"""
321
accum = []
322
def descend(dir_ie, dir_path):
323
kids = dir_ie.children.items()
324
kids.sort()
325
for name, ie in kids:
326
child_path = os.path.join(dir_path, name)
327
accum.append((child_path, ie))
328
if ie.kind == 'directory':
329
descend(ie, child_path)
330
331
descend(self.root, '')
332
return accum
333
334
335
def directories(self):
336
"""Return (path, entry) pairs for all directories, including the root.
337
"""
338
accum = []
339
def descend(parent_ie, parent_path):
340
accum.append((parent_path, parent_ie))
341
342
kids = [(ie.name, ie) for ie in parent_ie.children.itervalues() if ie.kind == 'directory']
343
kids.sort()
344
345
for name, child_ie in kids:
346
child_path = os.path.join(parent_path, name)
347
descend(child_ie, child_path)
348
descend(self.root, '')
349
return accum
303
350
304
351
305
352
306
def children(self, parent_id):
307
"""Return entries that are direct children of parent_id."""
308
return self._tree[parent_id]
309
310
311
312
# TODO: return all paths and entries
313
314
315
353
def __contains__(self, file_id):
316
354
"""True if this entry contains a file with given id.
317
355
318
356
>>> inv = Inventory()
319
>>> inv.add(InventoryEntry('123', 'foo.c'))
357
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
358
InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
320
359
>>> '123' in inv
321
360
True
322
361
>>> '456' in inv
329
368
"""Return the entry for given file_id.
330
369
331
370
>>> inv = Inventory()
332
>>> inv.add(InventoryEntry('123123', 'hello.c'))
371
>>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
372
InventoryEntry('123123', 'hello.c', kind='file', parent_id='TREE_ROOT')
333
373
>>> inv['123123'].name
334
374
'hello.c'
335
375
"""
336
return self._byid[file_id]
376
try:
377
return self._byid[file_id]
378
except KeyError:
379
if file_id == None:
380
raise BzrError("can't look up file_id None")
381
else:
382
raise BzrError("file_id {%s} not in inventory" % file_id)
383
384
385
def get_file_kind(self, file_id):
386
return self._byid[file_id].kind
387
388
def get_child(self, parent_id, filename):
389
return self[parent_id].children.get(filename)
337
390
338
391
339
392
def add(self, entry):
340
393
"""Add entry to inventory.
341
394
342
395
To add a file to a branch ready to be committed, use Branch.add,
343
which calls this."""
344
if entry.file_id in self:
345
bailout("inventory already contains entry with id {%s}" % entry.file_id)
346
347
if entry.parent_id != None:
348
if entry.parent_id not in self:
349
bailout("parent_id %s of new entry not found in inventory"
350
% entry.parent_id)
351
352
if self._tree[entry.parent_id].has_key(entry.name):
353
bailout("%s is already versioned"
354
% appendpath(self.id2path(entry.parent_id), entry.name))
396
which calls this.
397
398
Returns the new entry object.
399
"""
400
if entry.file_id in self._byid:
401
raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
402
403
if entry.parent_id == ROOT_ID or entry.parent_id is None:
404
entry.parent_id = self.root.file_id
405
406
try:
407
parent = self._byid[entry.parent_id]
408
except KeyError:
409
raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
410
411
if parent.children.has_key(entry.name):
412
raise BzrError("%s is already versioned" %
413
appendpath(self.id2path(parent.file_id), entry.name))
355
414
356
415
self._byid[entry.file_id] = entry
357
self._tree[entry.parent_id][entry.name] = entry
358
359
if entry.kind == 'directory':
360
self._tree[entry.file_id] = {}
416
parent.children[entry.name] = entry
417
return entry
418
419
420
def add_path(self, relpath, kind, file_id=None):
421
"""Add entry from a path.
422
423
The immediate parent must already be versioned.
424
425
Returns the new entry object."""
426
from bzrlib.branch import gen_file_id
427
428
parts = bzrlib.osutils.splitpath(relpath)
429
if len(parts) == 0:
430
raise BzrError("cannot re-add root of inventory")
431
432
if file_id == None:
433
file_id = gen_file_id(relpath)
434
435
parent_path = parts[:-1]
436
parent_id = self.path2id(parent_path)
437
if parent_id == None:
438
raise NotVersionedError(parent_path)
439
440
ie = InventoryEntry(file_id, parts[-1],
441
kind=kind, parent_id=parent_id)
442
return self.add(ie)
361
443
362
444
363
445
def __delitem__(self, file_id):
364
446
"""Remove entry by id.
365
447
366
448
>>> inv = Inventory()
367
>>> inv.add(InventoryEntry('123', 'foo.c'))
449
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
450
InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
368
451
>>> '123' in inv
369
452
True
370
453
>>> del inv['123']
373
456
"""
374
457
ie = self[file_id]
375
458
376
assert self._tree[ie.parent_id][ie.name] == ie
459
assert self[ie.parent_id].children[ie.name] == ie
377
460
378
461
# TODO: Test deleting all children; maybe hoist to a separate
379
462
# deltree method?
380
463
if ie.kind == 'directory':
381
for cie in self._tree[file_id].values():
464
for cie in ie.children.values():
382
465
del self[cie.file_id]
383
del self._tree[file_id]
466
del ie.children
384
467
385
468
del self._byid[file_id]
386
del self._tree[ie.parent_id][ie.name]
387
388
389
def id_set(self):
390
return Set(self._byid)
391
392
393
def to_element(self):
394
"""Convert to XML Element"""
395
e = Element('inventory')
396
e.text = '\n'
397
for path, ie in self.iter_entries():
398
e.append(ie.to_element())
399
return e
400
401
402
def from_element(cls, elt):
403
"""Construct from XML Element
404
405
>>> inv = Inventory()
406
>>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c'))
407
>>> elt = inv.to_element()
408
>>> inv2 = Inventory.from_element(elt)
409
>>> inv2 == inv
410
True
411
"""
412
assert elt.tag == 'inventory'
413
o = cls()
414
for e in elt:
415
o.add(InventoryEntry.from_element(e))
416
return o
417
418
from_element = classmethod(from_element)
419
420
421
def __cmp__(self, other):
469
del self[ie.parent_id].children[ie.name]
470
471
472
def __eq__(self, other):
422
473
"""Compare two sets by comparing their contents.
423
474
424
475
>>> i1 = Inventory()
425
476
>>> i2 = Inventory()
426
477
>>> i1 == i2
427
478
True
428
>>> i1.add(InventoryEntry('123', 'foo'))
479
>>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
480
InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
429
481
>>> i1 == i2
430
482
False
431
>>> i2.add(InventoryEntry('123', 'foo'))
483
>>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
484
InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
432
485
>>> i1 == i2
433
486
True
434
487
"""
435
if self is other:
436
return 0
437
438
488
if not isinstance(other, Inventory):
439
489
return NotImplemented
440
490
441
if self.id_set() ^ other.id_set():
442
return 1
443
444
for file_id in self._byid:
445
c = cmp(self[file_id], other[file_id])
446
if c: return c
447
448
return 0
449
450
451
def id2path(self, file_id):
452
"""Return as a list the path to file_id."""
491
if len(self._byid) != len(other._byid):
492
# shortcut: obviously not the same
493
return False
494
495
return self._byid == other._byid
496
497
498
def __ne__(self, other):
499
return not (self == other)
500
501
502
def __hash__(self):
503
raise ValueError('not hashable')
504
505
506
def get_idpath(self, file_id):
507
"""Return a list of file_ids for the path to an entry.
508
509
The list contains one element for each directory followed by
510
the id of the file itself. So the length of the returned list
511
is equal to the depth of the file in the tree, counting the
512
root directory as depth 1.
513
"""
453
514
p = []
454
515
while file_id != None:
455
ie = self[file_id]
456
p = [ie.name] + p
516
try:
517
ie = self._byid[file_id]
518
except KeyError:
519
raise BzrError("file_id {%s} not found in inventory" % file_id)
520
p.insert(0, ie.file_id)
457
521
file_id = ie.parent_id
458
return joinpath(p)
522
return p
523
524
525
def id2path(self, file_id):
526
"""Return as a list the path to file_id."""
527
528
# get all names, skipping root
529
p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
530
return os.sep.join(p)
459
531
460
532
461
533
467
539
468
540
This returns the entry of the last component in the path,
469
541
which may be either a file or a directory.
542
543
Returns None iff the path is not found.
470
544
"""
471
assert isinstance(name, types.StringTypes)
472
473
parent_id = None
474
for f in splitpath(name):
545
if isinstance(name, types.StringTypes):
546
name = splitpath(name)
547
548
mutter("lookup path %r" % name)
549
550
parent = self.root
551
for f in name:
475
552
try:
476
cie = self._tree[parent_id][f]
553
cie = parent.children[f]
477
554
assert cie.name == f
478
parent_id = cie.file_id
555
assert cie.parent_id == parent.file_id
556
parent = cie
479
557
except KeyError:
480
558
# or raise an error?
481
559
return None
482
560
483
return parent_id
484
485
486
def get_child(self, parent_id, child_name):
487
return self._tree[parent_id].get(child_name)
561
return parent.file_id
488
562
489
563
490
564
def has_filename(self, names):
492
566
493
567
494
568
def has_id(self, file_id):
495
assert isinstance(file_id, str)
496
569
return self._byid.has_key(file_id)
497
570
498
571
499
500
if __name__ == '__main__':
501
import doctest, inventory
502
doctest.testmod(inventory)
572
def rename(self, file_id, new_parent_id, new_name):
573
"""Move a file within the inventory.
574
575
This can change either the name, or the parent, or both.
576
577
This does not move the working file."""
578
if not is_valid_name(new_name):
579
raise BzrError("not an acceptable filename: %r" % new_name)
580
581
new_parent = self._byid[new_parent_id]
582
if new_name in new_parent.children:
583
raise BzrError("%r already exists in %r" % (new_name, self.id2path(new_parent_id)))
584
585
new_parent_idpath = self.get_idpath(new_parent_id)
586
if file_id in new_parent_idpath:
587
raise BzrError("cannot move directory %r into a subdirectory of itself, %r"
588
% (self.id2path(file_id), self.id2path(new_parent_id)))
589
590
file_ie = self._byid[file_id]
591
old_parent = self._byid[file_ie.parent_id]
592
593
# TODO: Don't leave things messed up if this fails
594
595
del old_parent.children[file_ie.name]
596
new_parent.children[new_name] = file_ie
597
598
file_ie.name = new_name
599
file_ie.parent_id = new_parent_id
600
601
602
603
604
_NAME_RE = None
605
606
def is_valid_name(name):
607
global _NAME_RE
608
if _NAME_RE == None:
609
_NAME_RE = re.compile(r'^[^/\\]+$')
610
611
return bool(_NAME_RE.match(name))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1