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