« 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/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- patches
- tools
- files 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
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):
42
38
"""Description of a versioned file.
43
39
44
40
An InventoryEntry has the following fields, which are also
45
41
present in the XML inventory-entry element:
46
42
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.)
43
* *file_id*
44
* *name*: (only the basename within the directory, must not
45
contain slashes)
46
* *kind*: "directory" or "file"
47
* *directory_id*: (if absent/null means the branch root directory)
48
* *text_sha1*: only for files
49
* *text_size*: in bytes, only for files
50
* *text_id*: identifier for the text version, only for files
51
52
InventoryEntries can also exist inside a WorkingTree
53
inventory, in which case they are not yet bound to a
54
particular revision of the file. In that case the text_sha1,
55
text_size and text_id are absent.
56
72
57
73
58
>>> i = Inventory()
74
59
>>> 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')
60
>>> i.add(InventoryEntry('123', 'src', kind='directory'))
61
>>> i.add(InventoryEntry('2323', 'hello.c', parent_id='123'))
80
62
>>> for j in i.iter_entries():
81
63
... print j
82
64
...
83
('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
65
('src', InventoryEntry('123', 'src', kind='directory', parent_id=None))
84
66
('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
85
>>> i.add(InventoryEntry('2323', 'bye.c', 'file', '123'))
67
>>> i.add(InventoryEntry('2323', 'bye.c', parent_id='123'))
86
68
Traceback (most recent call last):
87
69
...
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')
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'))
93
73
>>> i.path2id('src/wibble')
94
74
'2325'
95
75
>>> '2325' in i
96
76
True
97
>>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
98
InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
77
>>> i.add(InventoryEntry('2326', 'wibble.c', parent_id='2325'))
99
78
>>> i['2326']
100
79
InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
101
80
>>> for j in i.iter_entries():
109
88
src/wibble/wibble.c
110
89
>>> i.id2path('2326')
111
90
'src/wibble/wibble.c'
91
92
:todo: Maybe also keep the full path of the entry, and the children?
93
But those depend on its position within a particular inventory, and
94
it would be nice not to need to hold the backpointer here.
112
95
"""
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):
96
def __init__(self, file_id, name, kind='file', text_id=None,
97
parent_id=None):
120
98
"""Create an InventoryEntry
121
99
122
100
The filename must be a single component, relative to the
123
101
parent directory; it cannot be a whole path or relative name.
124
102
125
>>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
103
>>> e = InventoryEntry('123', 'hello.c')
126
104
>>> e.name
127
105
'hello.c'
128
106
>>> e.file_id
129
107
'123'
130
>>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
108
>>> e = InventoryEntry('123', 'src/hello.c')
131
109
Traceback (most recent call last):
132
BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
110
BzrError: ("InventoryEntry name is not a simple filename: 'src/hello.c'", [])
133
111
"""
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
112
113
if len(splitpath(name)) != 1:
114
bailout('InventoryEntry name is not a simple filename: %r'
115
% name)
116
142
117
self.file_id = file_id
143
118
self.name = name
119
assert kind in ['file', 'directory']
144
120
self.kind = kind
145
121
self.text_id = text_id
146
122
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
123
self.text_sha1 = None
124
self.text_size = None
160
125
161
126
162
127
def copy(self):
163
128
other = InventoryEntry(self.file_id, self.name, self.kind,
164
self.parent_id)
165
other.text_id = self.text_id
129
self.text_id, self.parent_id)
166
130
other.text_sha1 = self.text_sha1
167
131
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
132
return other
172
133
173
134
180
141
self.parent_id))
181
142
182
143
183
def __eq__(self, other):
144
def to_element(self):
145
"""Convert to XML element"""
146
e = Element('entry')
147
148
e.set('name', self.name)
149
e.set('file_id', self.file_id)
150
e.set('kind', self.kind)
151
152
if self.text_size is not None:
153
e.set('text_size', '%d' % self.text_size)
154
155
for f in ['text_id', 'text_sha1', 'parent_id']:
156
v = getattr(self, f)
157
if v is not None:
158
e.set(f, v)
159
160
e.tail = '\n'
161
162
return e
163
164
165
def from_element(cls, elt):
166
assert elt.tag == 'entry'
167
self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'))
168
self.text_id = elt.get('text_id')
169
self.text_sha1 = elt.get('text_sha1')
170
self.parent_id = elt.get('parent_id')
171
172
## mutter("read inventoryentry: %r" % (elt.attrib))
173
174
v = elt.get('text_size')
175
self.text_size = v and int(v)
176
177
return self
178
179
180
from_element = classmethod(from_element)
181
182
def __cmp__(self, other):
183
if self is other:
184
return 0
184
185
if not isinstance(other, InventoryEntry):
185
186
return NotImplemented
186
187
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):
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):
224
199
"""Inventory of versioned files in a tree.
225
200
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.
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.
229
207
230
208
The inventory represents a typical unix file tree, with
231
209
directories containing files and subdirectories. We never store
235
213
returned quickly.
236
214
237
215
InventoryEntry objects must not be modified after they are
238
inserted, other than through the Inventory API.
216
inserted.
239
217
240
218
>>> 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')
219
>>> inv.write_xml(sys.stdout)
220
<inventory>
221
</inventory>
222
>>> inv.add(InventoryEntry('123-123', 'hello.c'))
243
223
>>> inv['123-123'].name
244
224
'hello.c'
225
>>> for file_id in inv: print file_id
226
...
227
123-123
245
228
246
229
May be treated as an iterator or set to look up file ids:
247
230
254
237
255
238
>>> [x[0] for x in inv.iter_entries()]
256
239
['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')
240
241
>>> inv.write_xml(sys.stdout)
242
<inventory>
243
<entry file_id="123-123" kind="file" name="hello.c" />
244
</inventory>
245
260
246
"""
261
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):
262
262
"""Create or read an inventory.
263
263
264
264
If a working directory is specified, the inventory is read
265
265
from there. If the file is specified, read from that. If not,
266
266
the inventory is created empty.
267
268
The inventory is created with a default root directory, with
269
an id of None.
270
267
"""
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
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: {}}
288
273
289
274
290
275
def __iter__(self):
296
281
return len(self._byid)
297
282
298
283
299
def iter_entries(self, from_dir=None):
284
def iter_entries(self, parent_id=None):
300
285
"""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()
286
kids = self._tree[parent_id].items()
308
287
kids.sort()
309
288
for name, ie in kids:
310
289
yield name, ie
311
290
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
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
350
303
351
304
352
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
353
315
def __contains__(self, file_id):
354
316
"""True if this entry contains a file with given id.
355
317
356
318
>>> inv = Inventory()
357
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
358
InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
319
>>> inv.add(InventoryEntry('123', 'foo.c'))
359
320
>>> '123' in inv
360
321
True
361
322
>>> '456' in inv
368
329
"""Return the entry for given file_id.
369
330
370
331
>>> inv = Inventory()
371
>>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
372
InventoryEntry('123123', 'hello.c', kind='file', parent_id='TREE_ROOT')
332
>>> inv.add(InventoryEntry('123123', 'hello.c'))
373
333
>>> inv['123123'].name
374
334
'hello.c'
375
335
"""
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)
336
return self._byid[file_id]
390
337
391
338
392
339
def add(self, entry):
393
340
"""Add entry to inventory.
394
341
395
342
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))
343
which calls this."""
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))
414
355
415
356
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)
357
self._tree[entry.parent_id][entry.name] = entry
358
359
if entry.kind == 'directory':
360
self._tree[entry.file_id] = {}
443
361
444
362
445
363
def __delitem__(self, file_id):
446
364
"""Remove entry by id.
447
365
448
366
>>> inv = Inventory()
449
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
450
InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
367
>>> inv.add(InventoryEntry('123', 'foo.c'))
451
368
>>> '123' in inv
452
369
True
453
370
>>> del inv['123']
456
373
"""
457
374
ie = self[file_id]
458
375
459
assert self[ie.parent_id].children[ie.name] == ie
376
assert self._tree[ie.parent_id][ie.name] == ie
460
377
461
378
# TODO: Test deleting all children; maybe hoist to a separate
462
379
# deltree method?
463
380
if ie.kind == 'directory':
464
for cie in ie.children.values():
381
for cie in self._tree[file_id].values():
465
382
del self[cie.file_id]
466
del ie.children
383
del self._tree[file_id]
467
384
468
385
del self._byid[file_id]
469
del self[ie.parent_id].children[ie.name]
470
471
472
def __eq__(self, other):
386
del self._tree[ie.parent_id][ie.name]
387
388
389
def id_set(self):
390
return Set(self._byid)
391
392
393
def to_element(self):
394
"""Convert to XML Element"""
395
e = Element('inventory')
396
e.text = '\n'
397
for path, ie in self.iter_entries():
398
e.append(ie.to_element())
399
return e
400
401
402
def from_element(cls, elt):
403
"""Construct from XML Element
404
405
>>> inv = Inventory()
406
>>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c'))
407
>>> elt = inv.to_element()
408
>>> inv2 = Inventory.from_element(elt)
409
>>> inv2 == inv
410
True
411
"""
412
assert elt.tag == 'inventory'
413
o = cls()
414
for e in elt:
415
o.add(InventoryEntry.from_element(e))
416
return o
417
418
from_element = classmethod(from_element)
419
420
421
def __cmp__(self, other):
473
422
"""Compare two sets by comparing their contents.
474
423
475
424
>>> i1 = Inventory()
476
425
>>> i2 = Inventory()
477
426
>>> i1 == i2
478
427
True
479
>>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
480
InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
428
>>> i1.add(InventoryEntry('123', 'foo'))
481
429
>>> i1 == i2
482
430
False
483
>>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
484
InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
431
>>> i2.add(InventoryEntry('123', 'foo'))
485
432
>>> i1 == i2
486
433
True
487
434
"""
435
if self is other:
436
return 0
437
488
438
if not isinstance(other, Inventory):
489
439
return NotImplemented
490
440
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
"""
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."""
514
453
p = []
515
454
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)
455
ie = self[file_id]
456
p = [ie.name] + p
521
457
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)
458
return joinpath(p)
531
459
532
460
533
461
539
467
540
468
This returns the entry of the last component in the path,
541
469
which may be either a file or a directory.
542
543
Returns None iff the path is not found.
544
470
"""
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:
471
assert isinstance(name, types.StringTypes)
472
473
parent_id = None
474
for f in splitpath(name):
552
475
try:
553
cie = parent.children[f]
476
cie = self._tree[parent_id][f]
554
477
assert cie.name == f
555
assert cie.parent_id == parent.file_id
556
parent = cie
478
parent_id = cie.file_id
557
479
except KeyError:
558
480
# or raise an error?
559
481
return None
560
482
561
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)
562
488
563
489
564
490
def has_filename(self, names):
566
492
567
493
568
494
def has_id(self, file_id):
495
assert isinstance(file_id, str)
569
496
return self._byid.has_key(file_id)
570
497
571
498
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))
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