« back to all changes in this revision
Viewing changes to bzrlib/inventory.py
- browse files at revision 138
- compare with another revision
- download diff
- download tarball
- view history from revision 138
- Committer: mbp at sourcefrog
- Date: 2005-03-29 06:58:11 UTC
- Revision ID: mbp@sourcefrog.net-20050329065811-1a9363119ad79447
remove parallel tree from inventory;
store children directly in InventoryEntry
store children directly in InventoryEntry
- files added:
- bzrlib/tests.py
- files removed:
- .rsyncexclude
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- patches
- tools
- files renamed:
- bzrlib/util/elementtree/ => elementtree/
- files modified:
- .bzrignore
added
removed
bzrlib/inventory.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
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
17
"""Inventories map files to their name in a revision."""
18
19
# TODO: Maybe store inventory_id in the file? Not really needed.
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
32
34
33
35
import bzrlib
34
from bzrlib.errors import BzrError, BzrCheckError
35
36
36
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
37
37
from bzrlib.trace import mutter
38
from bzrlib.errors import NotVersionedError
39
40
38
41
class InventoryEntry(object):
39
class InventoryEntry(XMLMixin):
42
40
"""Description of a versioned file.
43
41
44
42
An InventoryEntry has the following fields, which are also
45
43
present in the XML inventory-entry element:
46
44
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.)
45
* *file_id*
46
* *name*: (only the basename within the directory, must not
47
contain slashes)
48
* *kind*: "directory" or "file"
49
* *directory_id*: (if absent/null means the branch root directory)
50
* *text_sha1*: only for files
51
* *text_size*: in bytes, only for files
52
* *text_id*: identifier for the text version, only for files
53
54
InventoryEntries can also exist inside a WorkingTree
55
inventory, in which case they are not yet bound to a
56
particular revision of the file. In that case the text_sha1,
57
text_size and text_id are absent.
58
72
59
73
60
>>> i = Inventory()
74
61
>>> i.path2id('')
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
>>> i.add(InventoryEntry('123', 'src', kind='directory'))
63
>>> i.add(InventoryEntry('2323', 'hello.c', parent_id='123'))
80
64
>>> for j in i.iter_entries():
81
65
... print j
82
66
...
83
('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
67
('src', InventoryEntry('123', 'src', kind='directory', parent_id=None))
84
68
('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
85
>>> i.add(InventoryEntry('2323', 'bye.c', 'file', '123'))
69
>>> i.add(InventoryEntry('2323', 'bye.c', parent_id='123'))
86
70
Traceback (most recent call last):
87
71
...
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')
72
BzrError: ('inventory already contains entry with id {2323}', [])
73
>>> i.add(InventoryEntry('2324', 'bye.c', parent_id='123'))
74
>>> i.add(InventoryEntry('2325', 'wibble', parent_id='123', kind='directory'))
93
75
>>> i.path2id('src/wibble')
94
76
'2325'
95
77
>>> '2325' in i
96
78
True
97
>>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
98
InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
79
>>> i.add(InventoryEntry('2326', 'wibble.c', parent_id='2325'))
99
80
>>> i['2326']
100
81
InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
101
82
>>> for j in i.iter_entries():
109
90
src/wibble/wibble.c
110
91
>>> i.id2path('2326')
111
92
'src/wibble/wibble.c'
93
94
:todo: Maybe also keep the full path of the entry, and the children?
95
But those depend on its position within a particular inventory, and
96
it would be nice not to need to hold the backpointer here.
112
97
"""
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
def __init__(self, file_id, name, kind='file', text_id=None,
99
parent_id=None):
120
100
"""Create an InventoryEntry
121
101
122
102
The filename must be a single component, relative to the
123
103
parent directory; it cannot be a whole path or relative name.
124
104
125
>>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
105
>>> e = InventoryEntry('123', 'hello.c')
126
106
>>> e.name
127
107
'hello.c'
128
108
>>> e.file_id
129
109
'123'
130
>>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
110
>>> e = InventoryEntry('123', 'src/hello.c')
131
111
Traceback (most recent call last):
132
BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
112
BzrError: ("InventoryEntry name is not a simple filename: 'src/hello.c'", [])
133
113
"""
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
114
115
if len(splitpath(name)) != 1:
116
bailout('InventoryEntry name is not a simple filename: %r'
117
% name)
118
142
119
self.file_id = file_id
143
120
self.name = name
121
assert kind in ['file', 'directory']
144
122
self.kind = kind
145
123
self.text_id = text_id
146
124
self.parent_id = parent_id
125
self.text_sha1 = None
126
self.text_size = None
147
127
if kind == 'directory':
148
128
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
160
129
161
130
162
131
def copy(self):
163
132
other = InventoryEntry(self.file_id, self.name, self.kind,
164
self.parent_id)
165
other.text_id = self.text_id
133
self.text_id, self.parent_id)
166
134
other.text_sha1 = self.text_sha1
167
135
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
171
136
return other
172
137
173
138
180
145
self.parent_id))
181
146
182
147
183
def __eq__(self, other):
148
def to_element(self):
149
"""Convert to XML element"""
150
e = Element('entry')
151
152
e.set('name', self.name)
153
e.set('file_id', self.file_id)
154
e.set('kind', self.kind)
155
156
if self.text_size is not None:
157
e.set('text_size', '%d' % self.text_size)
158
159
for f in ['text_id', 'text_sha1', 'parent_id']:
160
v = getattr(self, f)
161
if v is not None:
162
e.set(f, v)
163
164
e.tail = '\n'
165
166
return e
167
168
169
def from_element(cls, elt):
170
assert elt.tag == 'entry'
171
self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'))
172
self.text_id = elt.get('text_id')
173
self.text_sha1 = elt.get('text_sha1')
174
self.parent_id = elt.get('parent_id')
175
176
## mutter("read inventoryentry: %r" % (elt.attrib))
177
178
v = elt.get('text_size')
179
self.text_size = v and int(v)
180
181
return self
182
183
184
from_element = classmethod(from_element)
185
186
def __cmp__(self, other):
187
if self is other:
188
return 0
184
189
if not isinstance(other, InventoryEntry):
185
190
return NotImplemented
186
191
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):
192
return cmp(self.file_id, other.file_id) \
193
or cmp(self.name, other.name) \
194
or cmp(self.text_sha1, other.text_sha1) \
195
or cmp(self.text_size, other.text_size) \
196
or cmp(self.text_id, other.text_id) \
197
or cmp(self.parent_id, other.parent_id) \
198
or cmp(self.kind, other.kind)
199
200
201
202
class Inventory(XMLMixin):
224
203
"""Inventory of versioned files in a tree.
225
204
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.
205
An Inventory acts like a set of InventoryEntry items. You can
206
also look files up by their file_id or name.
207
208
May be read from and written to a metadata file in a tree. To
209
manipulate the inventory (for example to add a file), it is read
210
in, modified, and then written back out.
229
211
230
212
The inventory represents a typical unix file tree, with
231
213
directories containing files and subdirectories. We never store
235
217
returned quickly.
236
218
237
219
InventoryEntry objects must not be modified after they are
238
inserted, other than through the Inventory API.
220
inserted.
239
221
240
222
>>> inv = Inventory()
241
>>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
242
InventoryEntry('123-123', 'hello.c', kind='file', parent_id='TREE_ROOT')
223
>>> inv.write_xml(sys.stdout)
224
<inventory>
225
</inventory>
226
>>> inv.add(InventoryEntry('123-123', 'hello.c'))
243
227
>>> inv['123-123'].name
244
228
'hello.c'
245
229
254
238
255
239
>>> [x[0] for x in inv.iter_entries()]
256
240
['hello.c']
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')
241
242
>>> inv.write_xml(sys.stdout)
243
<inventory>
244
<entry file_id="123-123" kind="file" name="hello.c" />
245
</inventory>
246
260
247
"""
261
def __init__(self, root_id=ROOT_ID):
248
249
## TODO: Make sure only canonical filenames are stored.
250
251
## TODO: Do something sensible about the possible collisions on
252
## case-losing filesystems. Perhaps we should just always forbid
253
## such collisions.
254
255
## TODO: No special cases for root, rather just give it a file id
256
## like everything else.
257
258
## TODO: Probably change XML serialization to use nesting
259
260
def __init__(self):
262
261
"""Create or read an inventory.
263
262
264
263
If a working directory is specified, the inventory is read
265
264
from there. If the file is specified, read from that. If not,
266
265
the inventory is created empty.
267
268
The inventory is created with a default root directory, with
269
an id of None.
270
266
"""
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
267
self._root = InventoryEntry(None, '', kind='directory')
268
self._byid = {None: self._root}
288
269
289
270
290
271
def __iter__(self):
296
277
return len(self._byid)
297
278
298
279
299
def iter_entries(self, from_dir=None):
280
def iter_entries(self, parent_id=None):
300
281
"""Return (path, entry) pairs, in order by name."""
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()
282
kids = self[parent_id].children.items()
308
283
kids.sort()
309
284
for name, ie in kids:
310
285
yield name, ie
311
286
if ie.kind == 'directory':
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
287
for cn, cie in self.iter_entries(parent_id=ie.file_id):
288
yield joinpath([name, cn]), cie
289
290
291
def directories(self, include_root=True):
292
"""Return (path, entry) pairs for all directories.
293
"""
294
if include_root:
295
yield '', None
296
for path, entry in self.iter_entries():
297
if entry.kind == 'directory':
298
yield path, entry
350
299
351
300
352
301
354
303
"""True if this entry contains a file with given id.
355
304
356
305
>>> inv = Inventory()
357
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
358
InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
306
>>> inv.add(InventoryEntry('123', 'foo.c'))
359
307
>>> '123' in inv
360
308
True
361
309
>>> '456' in inv
368
316
"""Return the entry for given file_id.
369
317
370
318
>>> inv = Inventory()
371
>>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
372
InventoryEntry('123123', 'hello.c', kind='file', parent_id='TREE_ROOT')
319
>>> inv.add(InventoryEntry('123123', 'hello.c'))
373
320
>>> inv['123123'].name
374
321
'hello.c'
375
322
"""
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
323
return self._byid[file_id]
324
387
325
388
326
def get_child(self, parent_id, filename):
389
return self[parent_id].children.get(filename)
327
if parent_id == None:
328
return self._root.children.get(filename)
329
else:
330
return self[parent_id].children.get(filename)
390
331
391
332
392
333
def add(self, entry):
393
334
"""Add entry to inventory.
394
335
395
336
To add a file to a branch ready to be committed, use Branch.add,
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))
337
which calls this."""
338
if entry.file_id in self:
339
bailout("inventory already contains entry with id {%s}" % entry.file_id)
340
341
if entry.parent_id != None:
342
if entry.parent_id not in self:
343
bailout("parent_id %s of new entry not found in inventory"
344
% entry.parent_id)
345
# TODO: parent must be a directory
346
347
if self[entry.parent_id].children.has_key(entry.name):
348
bailout("%s is already versioned"
349
% appendpath(self.id2path(entry.parent_id), entry.name))
414
350
415
351
self._byid[entry.file_id] = entry
416
parent.children[entry.name] = entry
417
return entry
352
self[entry.parent_id].children[entry.name] = entry
418
353
419
354
420
355
def add_path(self, relpath, kind, file_id=None):
421
356
"""Add entry from a path.
422
357
423
The immediate parent must already be versioned.
424
425
Returns the new entry object."""
426
from bzrlib.branch import gen_file_id
427
358
The immediate parent must already be versioned"""
428
359
parts = bzrlib.osutils.splitpath(relpath)
429
360
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
361
bailout("cannot re-add root of inventory")
362
363
if file_id is None:
364
file_id = bzrlib.branch.gen_file_id(relpath)
365
366
parent_id = self.path2id(parts[:-1])
440
367
ie = InventoryEntry(file_id, parts[-1],
441
368
kind=kind, parent_id=parent_id)
442
369
return self.add(ie)
446
373
"""Remove entry by id.
447
374
448
375
>>> inv = Inventory()
449
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
450
InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
376
>>> inv.add(InventoryEntry('123', 'foo.c'))
451
377
>>> '123' in inv
452
378
True
453
379
>>> del inv['123']
469
395
del self[ie.parent_id].children[ie.name]
470
396
471
397
472
def __eq__(self, other):
398
def id_set(self):
399
return Set(self._byid)
400
401
402
def to_element(self):
403
"""Convert to XML Element"""
404
e = Element('inventory')
405
e.text = '\n'
406
for path, ie in self.iter_entries():
407
e.append(ie.to_element())
408
return e
409
410
411
def from_element(cls, elt):
412
"""Construct from XML Element
413
414
>>> inv = Inventory()
415
>>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c'))
416
>>> elt = inv.to_element()
417
>>> inv2 = Inventory.from_element(elt)
418
>>> inv2 == inv
419
True
420
"""
421
assert elt.tag == 'inventory'
422
o = cls()
423
for e in elt:
424
o.add(InventoryEntry.from_element(e))
425
return o
426
427
from_element = classmethod(from_element)
428
429
430
def __cmp__(self, other):
473
431
"""Compare two sets by comparing their contents.
474
432
475
433
>>> i1 = Inventory()
476
434
>>> i2 = Inventory()
477
435
>>> i1 == i2
478
436
True
479
>>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
480
InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
437
>>> i1.add(InventoryEntry('123', 'foo'))
481
438
>>> i1 == i2
482
439
False
483
>>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
484
InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
440
>>> i2.add(InventoryEntry('123', 'foo'))
485
441
>>> i1 == i2
486
442
True
487
443
"""
444
if self is other:
445
return 0
446
488
447
if not isinstance(other, Inventory):
489
448
return NotImplemented
490
449
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
"""
450
if self.id_set() ^ other.id_set():
451
return 1
452
453
for file_id in self._byid:
454
c = cmp(self[file_id], other[file_id])
455
if c: return c
456
457
return 0
458
459
460
def id2path(self, file_id):
461
"""Return as a list the path to file_id."""
514
462
p = []
515
463
while file_id != None:
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)
464
ie = self[file_id]
465
p = [ie.name] + p
521
466
file_id = ie.parent_id
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)
467
return joinpath(p)
531
468
532
469
533
470
539
476
540
477
This returns the entry of the last component in the path,
541
478
which may be either a file or a directory.
542
543
Returns None iff the path is not found.
544
479
"""
545
480
if isinstance(name, types.StringTypes):
546
481
name = splitpath(name)
547
482
548
mutter("lookup path %r" % name)
549
550
parent = self.root
483
parent = self[None]
551
484
for f in name:
552
485
try:
553
486
cie = parent.children[f]
554
487
assert cie.name == f
555
assert cie.parent_id == parent.file_id
556
488
parent = cie
557
489
except KeyError:
558
490
# or raise an error?
566
498
567
499
568
500
def has_id(self, file_id):
501
assert isinstance(file_id, str)
569
502
return self._byid.has_key(file_id)
570
503
571
504
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))
505
506
507
508
if __name__ == '__main__':
509
import doctest, inventory
510
doctest.testmod(inventory)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1