To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/inventory.py
- browse files at revision 131
- compare with another revision
- download diff
- download tarball
- view history from revision 131
- Committer: mbp at sourcefrog
- Date: 2005-03-29 02:31:34 UTC
- Revision ID: mbp@sourcefrog.net-20050329023134-2d1eb96c55831937
check size and sha1 of files retrieved from the tree
- files added:
- bzrlib/tests.py
- files removed:
- .rsyncexclude
- bzrlib/selftest
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- effbot
- effbot/org
- patches
- plugins
- plugins/changeset
- tools
- urlgrabber
- 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
18
"""Inventories map files to their name in a revision."""
19
20
# TODO: Maybe store inventory_id in the file? Not really needed.
21
22
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
23
__author__ = "Martin Pool <mbp@canonical.com>"
24
25
import sys, os.path, types
26
from sets import Set
27
28
try:
29
from cElementTree import Element, ElementTree, SubElement
30
except ImportError:
31
from elementtree.ElementTree import Element, ElementTree, SubElement
32
33
from xml import XMLMixin
34
from errors import bailout
24
35
25
36
import bzrlib
26
from bzrlib.errors import BzrError, BzrCheckError
27
28
37
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
29
38
from bzrlib.trace import mutter
30
from bzrlib.errors import NotVersionedError
31
32
39
33
class InventoryEntry(object):
40
class InventoryEntry(XMLMixin):
34
41
"""Description of a versioned file.
35
42
36
43
An InventoryEntry has the following fields, which are also
53
60
54
61
>>> i = Inventory()
55
62
>>> 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'))
63
>>> i.add(InventoryEntry('123', 'src', kind='directory'))
64
>>> i.add(InventoryEntry('2323', 'hello.c', parent_id='123'))
59
65
>>> for j in i.iter_entries():
60
66
... print j
61
67
...
62
('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
68
('src', InventoryEntry('123', 'src', kind='directory', parent_id=None))
63
69
('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
64
>>> i.add(InventoryEntry('2323', 'bye.c', 'file', '123'))
70
>>> i.add(InventoryEntry('2323', 'bye.c', parent_id='123'))
65
71
Traceback (most recent call last):
66
72
...
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'))
73
BzrError: ('inventory already contains entry with id {2323}', [])
74
>>> i.add(InventoryEntry('2324', 'bye.c', parent_id='123'))
75
>>> i.add(InventoryEntry('2325', 'wibble', parent_id='123', kind='directory'))
70
76
>>> i.path2id('src/wibble')
71
77
'2325'
72
78
>>> '2325' in i
73
79
True
74
>>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
80
>>> i.add(InventoryEntry('2326', 'wibble.c', parent_id='2325'))
75
81
>>> i['2326']
76
82
InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
77
83
>>> for j in i.iter_entries():
86
92
>>> i.id2path('2326')
87
93
'src/wibble/wibble.c'
88
94
89
TODO: Maybe also keep the full path of the entry, and the children?
95
:todo: Maybe also keep the full path of the entry, and the children?
90
96
But those depend on its position within a particular inventory, and
91
97
it would be nice not to need to hold the backpointer here.
92
98
"""
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):
99
def __init__(self, file_id, name, kind='file', text_id=None,
100
parent_id=None):
101
101
"""Create an InventoryEntry
102
102
103
103
The filename must be a single component, relative to the
104
104
parent directory; it cannot be a whole path or relative name.
105
105
106
>>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
106
>>> e = InventoryEntry('123', 'hello.c')
107
107
>>> e.name
108
108
'hello.c'
109
109
>>> e.file_id
110
110
'123'
111
>>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
111
>>> e = InventoryEntry('123', 'src/hello.c')
112
112
Traceback (most recent call last):
113
BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
113
BzrError: ("InventoryEntry name is not a simple filename: 'src/hello.c'", [])
114
114
"""
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
115
116
if len(splitpath(name)) != 1:
117
bailout('InventoryEntry name is not a simple filename: %r'
118
% name)
119
121
120
self.file_id = file_id
122
121
self.name = name
122
assert kind in ['file', 'directory']
123
123
self.kind = kind
124
124
self.text_id = text_id
125
125
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
126
self.text_sha1 = None
127
self.text_size = None
139
128
140
129
141
130
def copy(self):
142
131
other = InventoryEntry(self.file_id, self.name, self.kind,
143
self.parent_id, text_id=self.text_id)
132
self.text_id, self.parent_id)
144
133
other.text_sha1 = self.text_sha1
145
134
other.text_size = self.text_size
146
# note that children are *not* copied; they're pulled across when
147
# others are added
148
135
return other
149
136
150
137
159
146
160
147
def to_element(self):
161
148
"""Convert to XML element"""
162
from bzrlib.xml import Element
163
164
149
e = Element('entry')
165
150
166
151
e.set('name', self.name)
167
152
e.set('file_id', self.file_id)
168
153
e.set('kind', self.kind)
169
154
170
if self.text_size != None:
155
if self.text_size is not None:
171
156
e.set('text_size', '%d' % self.text_size)
172
157
173
for f in ['text_id', 'text_sha1']:
158
for f in ['text_id', 'text_sha1', 'parent_id']:
174
159
v = getattr(self, f)
175
if v != None:
160
if v is not None:
176
161
e.set(f, v)
177
162
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
163
e.tail = '\n'
186
164
187
165
return e
189
167
190
168
def from_element(cls, elt):
191
169
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)
170
self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'))
201
171
self.text_id = elt.get('text_id')
202
172
self.text_sha1 = elt.get('text_sha1')
173
self.parent_id = elt.get('parent_id')
203
174
204
175
## mutter("read inventoryentry: %r" % (elt.attrib))
205
176
211
182
212
183
from_element = classmethod(from_element)
213
184
214
def __eq__(self, other):
185
def __cmp__(self, other):
186
if self is other:
187
return 0
215
188
if not isinstance(other, InventoryEntry):
216
189
return NotImplemented
217
190
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):
191
return cmp(self.file_id, other.file_id) \
192
or cmp(self.name, other.name) \
193
or cmp(self.text_sha1, other.text_sha1) \
194
or cmp(self.text_size, other.text_size) \
195
or cmp(self.text_id, other.text_id) \
196
or cmp(self.parent_id, other.parent_id) \
197
or cmp(self.kind, other.kind)
198
199
200
201
class Inventory(XMLMixin):
253
202
"""Inventory of versioned files in a tree.
254
203
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.
204
An Inventory acts like a set of InventoryEntry items. You can
205
also look files up by their file_id or name.
206
207
May be read from and written to a metadata file in a tree. To
208
manipulate the inventory (for example to add a file), it is read
209
in, modified, and then written back out.
258
210
259
211
The inventory represents a typical unix file tree, with
260
212
directories containing files and subdirectories. We never store
264
216
returned quickly.
265
217
266
218
InventoryEntry objects must not be modified after they are
267
inserted, other than through the Inventory API.
219
inserted.
268
220
269
221
>>> inv = Inventory()
270
>>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
222
>>> inv.write_xml(sys.stdout)
223
<inventory>
224
</inventory>
225
>>> inv.add(InventoryEntry('123-123', 'hello.c'))
271
226
>>> inv['123-123'].name
272
227
'hello.c'
228
>>> for file_id in inv: print file_id
229
...
230
123-123
273
231
274
232
May be treated as an iterator or set to look up file ids:
275
233
282
240
283
241
>>> [x[0] for x in inv.iter_entries()]
284
242
['hello.c']
285
>>> inv = Inventory('TREE_ROOT-12345678-12345678')
286
>>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
243
244
>>> inv.write_xml(sys.stdout)
245
<inventory>
246
<entry file_id="123-123" kind="file" name="hello.c" />
247
</inventory>
248
287
249
"""
288
def __init__(self, root_id=ROOT_ID):
250
251
## TODO: Clear up handling of files in subdirectories; we probably
252
## do want to be able to just look them up by name but this
253
## probably means gradually walking down the path, looking up as we go.
254
255
## TODO: Make sure only canonical filenames are stored.
256
257
## TODO: Do something sensible about the possible collisions on
258
## case-losing filesystems. Perhaps we should just always forbid
259
## such collisions.
260
261
## _tree should probably just be stored as
262
## InventoryEntry._children on each directory.
263
264
def __init__(self):
289
265
"""Create or read an inventory.
290
266
291
267
If a working directory is specified, the inventory is read
292
268
from there. If the file is specified, read from that. If not,
293
269
the inventory is created empty.
294
295
The inventory is created with a default root directory, with
296
an id of None.
297
270
"""
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}
271
self._byid = dict()
272
273
# _tree is indexed by parent_id; at each level a map from name
274
# to ie. The None entry is the root.
275
self._tree = {None: {}}
304
276
305
277
306
278
def __iter__(self):
312
284
return len(self._byid)
313
285
314
286
315
def iter_entries(self, from_dir=None):
287
def iter_entries(self, parent_id=None):
316
288
"""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()
289
kids = self._tree[parent_id].items()
324
290
kids.sort()
325
291
for name, ie in kids:
326
292
yield name, ie
327
293
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
294
for cn, cie in self.iter_entries(parent_id=ie.file_id):
295
yield joinpath([name, cn]), cie
296
297
298
def directories(self, include_root=True):
299
"""Return (path, entry) pairs for all directories.
300
"""
301
if include_root:
302
yield '', None
303
for path, entry in self.iter_entries():
304
if entry.kind == 'directory':
305
yield path, entry
366
306
367
307
368
308
309
def children(self, parent_id):
310
"""Return entries that are direct children of parent_id."""
311
return self._tree[parent_id]
312
313
314
315
# TODO: return all paths and entries
316
317
369
318
def __contains__(self, file_id):
370
319
"""True if this entry contains a file with given id.
371
320
372
321
>>> inv = Inventory()
373
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
322
>>> inv.add(InventoryEntry('123', 'foo.c'))
374
323
>>> '123' in inv
375
324
True
376
325
>>> '456' in inv
383
332
"""Return the entry for given file_id.
384
333
385
334
>>> inv = Inventory()
386
>>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
335
>>> inv.add(InventoryEntry('123123', 'hello.c'))
387
336
>>> inv['123123'].name
388
337
'hello.c'
389
338
"""
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)
339
return self._byid[file_id]
404
340
405
341
406
342
def add(self, entry):
408
344
409
345
To add a file to a branch ready to be committed, use Branch.add,
410
346
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))
347
if entry.file_id in self:
348
bailout("inventory already contains entry with id {%s}" % entry.file_id)
349
350
if entry.parent_id != None:
351
if entry.parent_id not in self:
352
bailout("parent_id %s of new entry not found in inventory"
353
% entry.parent_id)
354
355
if self._tree[entry.parent_id].has_key(entry.name):
356
bailout("%s is already versioned"
357
% appendpath(self.id2path(entry.parent_id), entry.name))
425
358
426
359
self._byid[entry.file_id] = entry
427
parent.children[entry.name] = entry
360
self._tree[entry.parent_id][entry.name] = entry
361
362
if entry.kind == 'directory':
363
self._tree[entry.file_id] = {}
428
364
429
365
430
366
def add_path(self, relpath, kind, file_id=None):
431
367
"""Add entry from a path.
432
368
433
369
The immediate parent must already be versioned"""
434
from bzrlib.branch import gen_file_id
435
436
370
parts = bzrlib.osutils.splitpath(relpath)
437
371
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
372
bailout("cannot re-add root of inventory")
373
374
if file_id is None:
375
file_id = bzrlib.branch.gen_file_id(relpath)
376
377
parent_id = self.path2id(parts[:-1])
448
378
ie = InventoryEntry(file_id, parts[-1],
449
379
kind=kind, parent_id=parent_id)
450
380
return self.add(ie)
454
384
"""Remove entry by id.
455
385
456
386
>>> inv = Inventory()
457
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
387
>>> inv.add(InventoryEntry('123', 'foo.c'))
458
388
>>> '123' in inv
459
389
True
460
390
>>> del inv['123']
463
393
"""
464
394
ie = self[file_id]
465
395
466
assert self[ie.parent_id].children[ie.name] == ie
396
assert self._tree[ie.parent_id][ie.name] == ie
467
397
468
398
# TODO: Test deleting all children; maybe hoist to a separate
469
399
# deltree method?
470
400
if ie.kind == 'directory':
471
for cie in ie.children.values():
401
for cie in self._tree[file_id].values():
472
402
del self[cie.file_id]
473
del ie.children
403
del self._tree[file_id]
474
404
475
405
del self._byid[file_id]
476
del self[ie.parent_id].children[ie.name]
406
del self._tree[ie.parent_id][ie.name]
407
408
409
def id_set(self):
410
return Set(self._byid)
477
411
478
412
479
413
def to_element(self):
480
414
"""Convert to XML Element"""
481
from bzrlib.xml import Element
482
483
415
e = Element('inventory')
484
416
e.text = '\n'
485
if self.root.file_id not in (None, ROOT_ID):
486
e.set('file_id', self.root.file_id)
487
417
for path, ie in self.iter_entries():
488
418
e.append(ie.to_element())
489
419
return e
491
421
492
422
def from_element(cls, elt):
493
423
"""Construct from XML Element
494
424
495
425
>>> inv = Inventory()
496
>>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c', 'file', ROOT_ID))
426
>>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c'))
497
427
>>> elt = inv.to_element()
498
428
>>> inv2 = Inventory.from_element(elt)
499
429
>>> inv2 == inv
500
430
True
501
431
"""
502
# XXXX: doctest doesn't run this properly under python2.3
503
432
assert elt.tag == 'inventory'
504
root_id = elt.get('file_id') or ROOT_ID
505
o = cls(root_id)
433
o = cls()
506
434
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)
435
o.add(InventoryEntry.from_element(e))
511
436
return o
512
437
513
438
from_element = classmethod(from_element)
514
439
515
440
516
def __eq__(self, other):
441
def __cmp__(self, other):
517
442
"""Compare two sets by comparing their contents.
518
443
519
444
>>> i1 = Inventory()
520
445
>>> i2 = Inventory()
521
446
>>> i1 == i2
522
447
True
523
>>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
448
>>> i1.add(InventoryEntry('123', 'foo'))
524
449
>>> i1 == i2
525
450
False
526
>>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
451
>>> i2.add(InventoryEntry('123', 'foo'))
527
452
>>> i1 == i2
528
453
True
529
454
"""
455
if self is other:
456
return 0
457
530
458
if not isinstance(other, Inventory):
531
459
return NotImplemented
532
460
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
"""
461
if self.id_set() ^ other.id_set():
462
return 1
463
464
for file_id in self._byid:
465
c = cmp(self[file_id], other[file_id])
466
if c: return c
467
468
return 0
469
470
471
def id2path(self, file_id):
472
"""Return as a list the path to file_id."""
557
473
p = []
558
474
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)
475
ie = self[file_id]
476
p = [ie.name] + p
564
477
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)
478
return joinpath(p)
574
479
575
480
576
481
582
487
583
488
This returns the entry of the last component in the path,
584
489
which may be either a file or a directory.
585
586
Returns None iff the path is not found.
587
490
"""
588
491
if isinstance(name, types.StringTypes):
589
492
name = splitpath(name)
590
493
591
mutter("lookup path %r" % name)
592
593
parent = self.root
494
parent_id = None
594
495
for f in name:
595
496
try:
596
cie = parent.children[f]
497
cie = self._tree[parent_id][f]
597
498
assert cie.name == f
598
assert cie.parent_id == parent.file_id
599
parent = cie
499
parent_id = cie.file_id
600
500
except KeyError:
601
501
# or raise an error?
602
502
return None
603
503
604
return parent.file_id
504
return parent_id
505
506
507
def get_child(self, parent_id, child_name):
508
return self._tree[parent_id].get(child_name)
605
509
606
510
607
511
def has_filename(self, names):
609
513
610
514
611
515
def has_id(self, file_id):
516
assert isinstance(file_id, str)
612
517
return self._byid.has_key(file_id)
613
518
614
519
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 = re.compile(r'^[^/\\]+$')
648
649
def is_valid_name(name):
650
return bool(_NAME_RE.match(name))
520
521
522
523
if __name__ == '__main__':
524
import doctest, inventory
525
doctest.testmod(inventory)
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0