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