« back to all changes in this revision
Viewing changes to bzrlib/inventory.py
- browse files at revision 6
- compare with another revision
- download diff
- download tarball
- view history from revision 6
- Committer: mbp at sourcefrog
- Date: 2005-03-09 04:51:05 UTC
- Revision ID: mbp@sourcefrog.net-20050309045105-d02cd410a115da2c
import all docs from arch
- files added:
- bzrlib/tests.py
- files removed:
- .bzrignore
- 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
- notes
- patches
- tools
- 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
# TODO: Maybe also keep the full path of the entry, and the children?
19
# But those depend on its position within a particular inventory, and
20
# it would be nice not to need to hold the backpointer here.
21
22
# TODO: Perhaps split InventoryEntry into subclasses for files,
23
# directories, etc etc.
24
25
26
# This should really be an id randomly assigned when the tree is
27
# created, but it's not for now.
28
ROOT_ID = "TREE_ROOT"
29
30
31
import sys, os.path, types, re
32
33
import bzrlib
34
from bzrlib.errors import BzrError, BzrCheckError
35
36
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
37
from bzrlib.trace import mutter
38
from bzrlib.errors import NotVersionedError
39
40
41
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
from xml import XMLMixin
28
from ElementTree import ElementTree, Element
29
from errors import bailout
30
from osutils import uuid, quotefn, splitpath, joinpath, appendpath
31
from trace import mutter
32
33
class InventoryEntry(XMLMixin):
42
34
"""Description of a versioned file.
43
35
44
36
An InventoryEntry has the following fields, which are also
45
37
present in the XML inventory-entry element:
46
38
47
file_id
48
49
name
50
(within the parent directory)
51
52
kind
53
'directory' or 'file'
54
55
parent_id
56
file_id of the parent directory, or ROOT_ID
57
58
entry_version
59
the revision_id in which the name or parent of this file was
60
last changed
61
62
text_sha1
63
sha-1 of the text of the file
64
65
text_size
66
size in bytes of the text of the file
67
68
text_version
69
the revision_id in which the text of this file was introduced
70
71
(reading a version 4 tree created a text_id field.)
39
* *file_id*
40
* *name*: (only the basename within the directory, must not
41
contain slashes)
42
* *kind*: "directory" or "file"
43
* *directory_id*: (if absent/null means the branch root directory)
44
* *text_sha1*: only for files
45
* *text_size*: in bytes, only for files
46
* *text_id*: identifier for the text version, only for files
47
48
InventoryEntries can also exist inside a WorkingTree
49
inventory, in which case they are not yet bound to a
50
particular revision of the file. In that case the text_sha1,
51
text_size and text_id are absent.
52
72
53
73
54
>>> i = Inventory()
74
55
>>> i.path2id('')
75
'TREE_ROOT'
76
>>> i.add(InventoryEntry('123', 'src', 'directory', ROOT_ID))
77
InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT')
78
>>> i.add(InventoryEntry('2323', 'hello.c', 'file', parent_id='123'))
79
InventoryEntry('2323', 'hello.c', kind='file', parent_id='123')
56
>>> i.add(InventoryEntry('123', 'src', kind='directory'))
57
>>> i.add(InventoryEntry('2323', 'hello.c', parent_id='123'))
80
58
>>> for j in i.iter_entries():
81
59
... print j
82
60
...
83
('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
61
('src', InventoryEntry('123', 'src', kind='directory', parent_id=None))
84
62
('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
85
>>> i.add(InventoryEntry('2323', 'bye.c', 'file', '123'))
63
>>> i.add(InventoryEntry('2323', 'bye.c', parent_id='123'))
86
64
Traceback (most recent call last):
87
65
...
88
BzrError: inventory already contains entry with id {2323}
89
>>> i.add(InventoryEntry('2324', 'bye.c', 'file', '123'))
90
InventoryEntry('2324', 'bye.c', kind='file', parent_id='123')
91
>>> i.add(InventoryEntry('2325', 'wibble', 'directory', '123'))
92
InventoryEntry('2325', 'wibble', kind='directory', parent_id='123')
66
BzrError: ('inventory already contains entry with id {2323}', [])
67
>>> i.add(InventoryEntry('2324', 'bye.c', parent_id='123'))
68
>>> i.add(InventoryEntry('2325', 'wibble', parent_id='123', kind='directory'))
93
69
>>> i.path2id('src/wibble')
94
70
'2325'
95
71
>>> '2325' in i
96
72
True
97
>>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
98
InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
73
>>> i.add(InventoryEntry('2326', 'wibble.c', parent_id='2325'))
99
74
>>> i['2326']
100
75
InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
101
76
>>> for j in i.iter_entries():
109
84
src/wibble/wibble.c
110
85
>>> i.id2path('2326')
111
86
'src/wibble/wibble.c'
87
88
:todo: Maybe also keep the full path of the entry, and the children?
89
But those depend on its position within a particular inventory, and
90
it would be nice not to need to hold the backpointer here.
112
91
"""
113
114
__slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
115
'text_id', 'parent_id', 'children',
116
'text_version', 'entry_version', ]
117
118
119
def __init__(self, file_id, name, kind, parent_id, text_id=None):
92
def __init__(self, file_id, name, kind='file', text_id=None,
93
parent_id=None):
120
94
"""Create an InventoryEntry
121
95
122
96
The filename must be a single component, relative to the
123
97
parent directory; it cannot be a whole path or relative name.
124
98
125
>>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
99
>>> e = InventoryEntry('123', 'hello.c')
126
100
>>> e.name
127
101
'hello.c'
128
102
>>> e.file_id
129
103
'123'
130
>>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
104
>>> e = InventoryEntry('123', 'src/hello.c')
131
105
Traceback (most recent call last):
132
BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
106
BzrError: ("InventoryEntry name is not a simple filename: 'src/hello.c'", [])
133
107
"""
134
assert isinstance(name, basestring), name
135
if '/' in name or '\\' in name:
136
raise BzrCheckError('InventoryEntry name %r is invalid' % name)
137
138
self.text_version = None
139
self.entry_version = None
140
self.text_sha1 = None
141
self.text_size = None
108
109
if len(splitpath(name)) != 1:
110
bailout('InventoryEntry name is not a simple filename: %r'
111
% name)
112
142
113
self.file_id = file_id
143
114
self.name = name
115
assert kind in ['file', 'directory']
144
116
self.kind = kind
145
117
self.text_id = text_id
146
118
self.parent_id = parent_id
147
if kind == 'directory':
148
self.children = {}
149
elif kind == 'file':
150
pass
151
else:
152
raise BzrError("unhandled entry kind %r" % kind)
153
154
155
156
def sorted_children(self):
157
l = self.children.items()
158
l.sort()
159
return l
119
self.text_sha1 = None
120
self.text_size = None
160
121
161
122
162
123
def copy(self):
163
124
other = InventoryEntry(self.file_id, self.name, self.kind,
164
self.parent_id)
165
other.text_id = self.text_id
125
self.text_id, self.parent_id)
166
126
other.text_sha1 = self.text_sha1
167
127
other.text_size = self.text_size
168
other.text_version = self.text_version
169
# note that children are *not* copied; they're pulled across when
170
# others are added
171
128
return other
172
129
173
130
180
137
self.parent_id))
181
138
182
139
183
def __eq__(self, other):
140
def to_element(self):
141
"""Convert to XML element"""
142
e = Element('entry')
143
144
e.set('name', self.name)
145
e.set('file_id', self.file_id)
146
e.set('kind', self.kind)
147
148
if self.text_size is not None:
149
e.set('text_size', '%d' % self.text_size)
150
151
for f in ['text_id', 'text_sha1', 'parent_id']:
152
v = getattr(self, f)
153
if v is not None:
154
e.set(f, v)
155
156
e.tail = '\n'
157
158
return e
159
160
161
def from_element(cls, elt):
162
assert elt.tag == 'entry'
163
self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'))
164
self.text_id = elt.get('text_id')
165
self.text_sha1 = elt.get('text_sha1')
166
self.parent_id = elt.get('parent_id')
167
168
## mutter("read inventoryentry: %r" % (elt.attrib))
169
170
v = elt.get('text_size')
171
self.text_size = v and int(v)
172
173
return self
174
175
176
from_element = classmethod(from_element)
177
178
def __cmp__(self, other):
179
if self is other:
180
return 0
184
181
if not isinstance(other, InventoryEntry):
185
182
return NotImplemented
186
183
187
return (self.file_id == other.file_id) \
188
and (self.name == other.name) \
189
and (self.text_sha1 == other.text_sha1) \
190
and (self.text_size == other.text_size) \
191
and (self.text_id == other.text_id) \
192
and (self.parent_id == other.parent_id) \
193
and (self.kind == other.kind) \
194
and (self.text_version == other.text_version) \
195
and (self.entry_version == other.entry_version)
196
197
198
def __ne__(self, other):
199
return not (self == other)
200
201
def __hash__(self):
202
raise ValueError('not hashable')
203
204
205
206
class RootEntry(InventoryEntry):
207
def __init__(self, file_id):
208
self.file_id = file_id
209
self.children = {}
210
self.kind = 'root_directory'
211
self.parent_id = None
212
self.name = ''
213
214
def __eq__(self, other):
215
if not isinstance(other, RootEntry):
216
return NotImplemented
217
218
return (self.file_id == other.file_id) \
219
and (self.children == other.children)
220
221
222
223
class Inventory(object):
184
return cmp(self.file_id, other.file_id) \
185
or cmp(self.name, other.name) \
186
or cmp(self.text_sha1, other.text_sha1) \
187
or cmp(self.text_size, other.text_size) \
188
or cmp(self.text_id, other.text_id) \
189
or cmp(self.parent_id, other.parent_id) \
190
or cmp(self.kind, other.kind)
191
192
193
194
class Inventory(XMLMixin):
224
195
"""Inventory of versioned files in a tree.
225
196
226
This describes which file_id is present at each point in the tree,
227
and possibly the SHA-1 or other information about the file.
228
Entries can be looked up either by path or by file_id.
197
An Inventory acts like a set of InventoryEntry items. You can
198
also look files up by their file_id or name.
199
200
May be read from and written to a metadata file in a tree. To
201
manipulate the inventory (for example to add a file), it is read
202
in, modified, and then written back out.
229
203
230
204
The inventory represents a typical unix file tree, with
231
205
directories containing files and subdirectories. We never store
235
209
returned quickly.
236
210
237
211
InventoryEntry objects must not be modified after they are
238
inserted, other than through the Inventory API.
212
inserted.
239
213
240
214
>>> inv = Inventory()
241
>>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
242
InventoryEntry('123-123', 'hello.c', kind='file', parent_id='TREE_ROOT')
215
>>> inv.write_xml(sys.stdout)
216
<inventory>
217
</inventory>
218
>>> inv.add(InventoryEntry('123-123', 'hello.c'))
243
219
>>> inv['123-123'].name
244
220
'hello.c'
221
>>> for file_id in inv: print file_id
222
...
223
123-123
245
224
246
225
May be treated as an iterator or set to look up file ids:
247
226
254
233
255
234
>>> [x[0] for x in inv.iter_entries()]
256
235
['hello.c']
257
>>> inv = Inventory('TREE_ROOT-12345678-12345678')
258
>>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
259
InventoryEntry('123-123', 'hello.c', kind='file', parent_id='TREE_ROOT-12345678-12345678')
236
237
>>> inv.write_xml(sys.stdout)
238
<inventory>
239
<entry file_id="123-123" kind="file" name="hello.c" />
240
</inventory>
241
260
242
"""
261
def __init__(self, root_id=ROOT_ID):
243
244
## TODO: Clear up handling of files in subdirectories; we probably
245
## do want to be able to just look them up by name but this
246
## probably means gradually walking down the path, looking up as we go.
247
248
## TODO: Make sure only canonical filenames are stored.
249
250
## TODO: Do something sensible about the possible collisions on
251
## case-losing filesystems. Perhaps we should just always forbid
252
## such collisions.
253
254
## _tree should probably just be stored as
255
## InventoryEntry._children on each directory.
256
257
def __init__(self):
262
258
"""Create or read an inventory.
263
259
264
260
If a working directory is specified, the inventory is read
265
261
from there. If the file is specified, read from that. If not,
266
262
the inventory is created empty.
267
268
The inventory is created with a default root directory, with
269
an id of None.
270
263
"""
271
# We are letting Branch(init=True) create a unique inventory
272
# root id. Rather than generating a random one here.
273
#if root_id is None:
274
# root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
275
self.root = RootEntry(root_id)
276
self._byid = {self.root.file_id: self.root}
277
278
279
def copy(self):
280
other = Inventory(self.root.file_id)
281
# copy recursively so we know directories will be added before
282
# their children. There are more efficient ways than this...
283
for path, entry in self.iter_entries():
284
if entry == self.root:
285
continue
286
other.add(entry.copy())
287
return other
264
self._byid = dict()
265
266
# _tree is indexed by parent_id; at each level a map from name
267
# to ie. The None entry is the root.
268
self._tree = {None: {}}
288
269
289
270
290
271
def __iter__(self):
296
277
return len(self._byid)
297
278
298
279
299
def iter_entries(self, from_dir=None):
280
def iter_entries(self, parent_id=None):
300
281
"""Return (path, entry) pairs, in order by name."""
301
if from_dir == None:
302
assert self.root
303
from_dir = self.root
304
elif isinstance(from_dir, basestring):
305
from_dir = self._byid[from_dir]
306
307
kids = from_dir.children.items()
282
kids = self._tree[parent_id].items()
308
283
kids.sort()
309
284
for name, ie in kids:
310
285
yield name, ie
311
286
if ie.kind == 'directory':
312
for cn, cie in self.iter_entries(from_dir=ie.file_id):
313
yield os.path.join(name, cn), cie
314
315
316
def entries(self):
317
"""Return list of (path, ie) for all entries except the root.
318
319
This may be faster than iter_entries.
320
"""
321
accum = []
322
def descend(dir_ie, dir_path):
323
kids = dir_ie.children.items()
324
kids.sort()
325
for name, ie in kids:
326
child_path = os.path.join(dir_path, name)
327
accum.append((child_path, ie))
328
if ie.kind == 'directory':
329
descend(ie, child_path)
330
331
descend(self.root, '')
332
return accum
333
334
335
def directories(self):
336
"""Return (path, entry) pairs for all directories, including the root.
337
"""
338
accum = []
339
def descend(parent_ie, parent_path):
340
accum.append((parent_path, parent_ie))
341
342
kids = [(ie.name, ie) for ie in parent_ie.children.itervalues() if ie.kind == 'directory']
343
kids.sort()
344
345
for name, child_ie in kids:
346
child_path = os.path.join(parent_path, name)
347
descend(child_ie, child_path)
348
descend(self.root, '')
349
return accum
287
for cn, cie in self.iter_entries(parent_id=ie.file_id):
288
yield joinpath([name, cn]), cie
289
290
291
def directories(self, include_root=True):
292
"""Return (path, entry) pairs for all directories.
293
"""
294
if include_root:
295
yield '', None
296
for path, entry in self.iter_entries():
297
if entry.kind == 'directory':
298
yield path, entry
350
299
351
300
352
301
302
def children(self, parent_id):
303
"""Return entries that are direct children of parent_id."""
304
return self._tree[parent_id]
305
306
307
308
# TODO: return all paths and entries
309
310
353
311
def __contains__(self, file_id):
354
312
"""True if this entry contains a file with given id.
355
313
356
314
>>> inv = Inventory()
357
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
358
InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
315
>>> inv.add(InventoryEntry('123', 'foo.c'))
359
316
>>> '123' in inv
360
317
True
361
318
>>> '456' in inv
368
325
"""Return the entry for given file_id.
369
326
370
327
>>> inv = Inventory()
371
>>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
372
InventoryEntry('123123', 'hello.c', kind='file', parent_id='TREE_ROOT')
328
>>> inv.add(InventoryEntry('123123', 'hello.c'))
373
329
>>> inv['123123'].name
374
330
'hello.c'
375
331
"""
376
try:
377
return self._byid[file_id]
378
except KeyError:
379
if file_id == None:
380
raise BzrError("can't look up file_id None")
381
else:
382
raise BzrError("file_id {%s} not in inventory" % file_id)
383
384
385
def get_file_kind(self, file_id):
386
return self._byid[file_id].kind
387
388
def get_child(self, parent_id, filename):
389
return self[parent_id].children.get(filename)
332
return self._byid[file_id]
390
333
391
334
392
335
def add(self, entry):
393
336
"""Add entry to inventory.
394
337
395
338
To add a file to a branch ready to be committed, use Branch.add,
396
which calls this.
397
398
Returns the new entry object.
399
"""
400
if entry.file_id in self._byid:
401
raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
402
403
if entry.parent_id == ROOT_ID or entry.parent_id is None:
404
entry.parent_id = self.root.file_id
405
406
try:
407
parent = self._byid[entry.parent_id]
408
except KeyError:
409
raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
410
411
if parent.children.has_key(entry.name):
412
raise BzrError("%s is already versioned" %
413
appendpath(self.id2path(parent.file_id), entry.name))
339
which calls this."""
340
if entry.file_id in self:
341
bailout("inventory already contains entry with id {%s}" % entry.file_id)
342
343
if entry.parent_id != None:
344
if entry.parent_id not in self:
345
bailout("parent_id %s of new entry not found in inventory"
346
% entry.parent_id)
347
348
if self._tree[entry.parent_id].has_key(entry.name):
349
bailout("%s is already versioned"
350
% appendpath(self.id2path(entry.parent_id), entry.name))
414
351
415
352
self._byid[entry.file_id] = entry
416
parent.children[entry.name] = entry
417
return entry
418
419
420
def add_path(self, relpath, kind, file_id=None):
421
"""Add entry from a path.
422
423
The immediate parent must already be versioned.
424
425
Returns the new entry object."""
426
from bzrlib.branch import gen_file_id
427
428
parts = bzrlib.osutils.splitpath(relpath)
429
if len(parts) == 0:
430
raise BzrError("cannot re-add root of inventory")
431
432
if file_id == None:
433
file_id = gen_file_id(relpath)
434
435
parent_path = parts[:-1]
436
parent_id = self.path2id(parent_path)
437
if parent_id == None:
438
raise NotVersionedError(parent_path)
439
440
ie = InventoryEntry(file_id, parts[-1],
441
kind=kind, parent_id=parent_id)
442
return self.add(ie)
353
self._tree[entry.parent_id][entry.name] = entry
354
355
if entry.kind == 'directory':
356
self._tree[entry.file_id] = {}
443
357
444
358
445
359
def __delitem__(self, file_id):
446
360
"""Remove entry by id.
447
361
448
362
>>> inv = Inventory()
449
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
450
InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
363
>>> inv.add(InventoryEntry('123', 'foo.c'))
451
364
>>> '123' in inv
452
365
True
453
366
>>> del inv['123']
456
369
"""
457
370
ie = self[file_id]
458
371
459
assert self[ie.parent_id].children[ie.name] == ie
372
assert self._tree[ie.parent_id][ie.name] == ie
460
373
461
374
# TODO: Test deleting all children; maybe hoist to a separate
462
375
# deltree method?
463
376
if ie.kind == 'directory':
464
for cie in ie.children.values():
377
for cie in self._tree[file_id].values():
465
378
del self[cie.file_id]
466
del ie.children
379
del self._tree[file_id]
467
380
468
381
del self._byid[file_id]
469
del self[ie.parent_id].children[ie.name]
470
471
472
def __eq__(self, other):
382
del self._tree[ie.parent_id][ie.name]
383
384
385
def id_set(self):
386
return Set(self._byid)
387
388
389
def to_element(self):
390
"""Convert to XML Element"""
391
e = Element('inventory')
392
e.text = '\n'
393
for path, ie in self.iter_entries():
394
e.append(ie.to_element())
395
return e
396
397
398
def from_element(cls, elt):
399
"""Construct from XML Element
400
401
>>> inv = Inventory()
402
>>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c'))
403
>>> elt = inv.to_element()
404
>>> inv2 = Inventory.from_element(elt)
405
>>> inv2 == inv
406
True
407
"""
408
assert elt.tag == 'inventory'
409
o = cls()
410
for e in elt:
411
o.add(InventoryEntry.from_element(e))
412
return o
413
414
from_element = classmethod(from_element)
415
416
417
def __cmp__(self, other):
473
418
"""Compare two sets by comparing their contents.
474
419
475
420
>>> i1 = Inventory()
476
421
>>> i2 = Inventory()
477
422
>>> i1 == i2
478
423
True
479
>>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
480
InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
424
>>> i1.add(InventoryEntry('123', 'foo'))
481
425
>>> i1 == i2
482
426
False
483
>>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
484
InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
427
>>> i2.add(InventoryEntry('123', 'foo'))
485
428
>>> i1 == i2
486
429
True
487
430
"""
431
if self is other:
432
return 0
433
488
434
if not isinstance(other, Inventory):
489
435
return NotImplemented
490
436
491
if len(self._byid) != len(other._byid):
492
# shortcut: obviously not the same
493
return False
494
495
return self._byid == other._byid
496
497
498
def __ne__(self, other):
499
return not (self == other)
500
501
502
def __hash__(self):
503
raise ValueError('not hashable')
504
505
506
def get_idpath(self, file_id):
507
"""Return a list of file_ids for the path to an entry.
508
509
The list contains one element for each directory followed by
510
the id of the file itself. So the length of the returned list
511
is equal to the depth of the file in the tree, counting the
512
root directory as depth 1.
513
"""
437
if self.id_set() ^ other.id_set():
438
return 1
439
440
for file_id in self._byid:
441
c = cmp(self[file_id], other[file_id])
442
if c: return c
443
444
return 0
445
446
447
def id2path(self, file_id):
448
"""Return as a list the path to file_id."""
514
449
p = []
515
450
while file_id != None:
516
try:
517
ie = self._byid[file_id]
518
except KeyError:
519
raise BzrError("file_id {%s} not found in inventory" % file_id)
520
p.insert(0, ie.file_id)
451
ie = self[file_id]
452
p = [ie.name] + p
521
453
file_id = ie.parent_id
522
return p
523
524
525
def id2path(self, file_id):
526
"""Return as a list the path to file_id."""
527
528
# get all names, skipping root
529
p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
530
return os.sep.join(p)
454
return joinpath(p)
531
455
532
456
533
457
539
463
540
464
This returns the entry of the last component in the path,
541
465
which may be either a file or a directory.
542
543
Returns None iff the path is not found.
544
466
"""
545
if isinstance(name, types.StringTypes):
546
name = splitpath(name)
547
548
mutter("lookup path %r" % name)
549
550
parent = self.root
551
for f in name:
467
assert isinstance(name, types.StringTypes)
468
469
parent_id = None
470
for f in splitpath(name):
552
471
try:
553
cie = parent.children[f]
472
cie = self._tree[parent_id][f]
554
473
assert cie.name == f
555
assert cie.parent_id == parent.file_id
556
parent = cie
474
parent_id = cie.file_id
557
475
except KeyError:
558
476
# or raise an error?
559
477
return None
560
478
561
return parent.file_id
479
return parent_id
480
481
482
def get_child(self, parent_id, child_name):
483
return self._tree[parent_id].get(child_name)
562
484
563
485
564
486
def has_filename(self, names):
566
488
567
489
568
490
def has_id(self, file_id):
491
assert isinstance(file_id, str)
569
492
return self._byid.has_key(file_id)
570
493
571
494
572
def rename(self, file_id, new_parent_id, new_name):
573
"""Move a file within the inventory.
574
575
This can change either the name, or the parent, or both.
576
577
This does not move the working file."""
578
if not is_valid_name(new_name):
579
raise BzrError("not an acceptable filename: %r" % new_name)
580
581
new_parent = self._byid[new_parent_id]
582
if new_name in new_parent.children:
583
raise BzrError("%r already exists in %r" % (new_name, self.id2path(new_parent_id)))
584
585
new_parent_idpath = self.get_idpath(new_parent_id)
586
if file_id in new_parent_idpath:
587
raise BzrError("cannot move directory %r into a subdirectory of itself, %r"
588
% (self.id2path(file_id), self.id2path(new_parent_id)))
589
590
file_ie = self._byid[file_id]
591
old_parent = self._byid[file_ie.parent_id]
592
593
# TODO: Don't leave things messed up if this fails
594
595
del old_parent.children[file_ie.name]
596
new_parent.children[new_name] = file_ie
597
598
file_ie.name = new_name
599
file_ie.parent_id = new_parent_id
600
601
602
603
604
_NAME_RE = None
605
606
def is_valid_name(name):
607
global _NAME_RE
608
if _NAME_RE == None:
609
_NAME_RE = re.compile(r'^[^/\\]+$')
610
611
return bool(_NAME_RE.match(name))
495
496
if __name__ == '__main__':
497
import doctest, inventory
498
doctest.testmod(inventory)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1