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