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