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