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