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