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