« back to all changes in this revision
Viewing changes to bzrlib/inventory.py
- browse files at revision 48
- compare with another revision
- download diff
- download tarball
- view history from revision 48
- Committer: Martin Pool
- Date: 2005-03-15 05:19:54 UTC
- Revision ID: mbp@sourcefrog.net-20050315051954-e4bdd6dfd26f8ecf
witty comment
- files added:
- bzrlib/tests.py
- files removed:
- .rsyncexclude
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/store
- bzrlib/transport
- 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/store/__init__.py => bzrlib/store.py
- files modified:
- .bzrignore
- bzr *
added
removed
bzrlib/inventory.py
1
# (C) 2005 Canonical Ltd
2
#
1
#! /usr/bin/env python
2
# -*- coding: UTF-8 -*-
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
5
6
# the Free Software Foundation; either version 2 of the License, or
6
7
# (at your option) any later version.
7
#
8
8
9
# This program is distributed in the hope that it will be useful,
9
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
12
# GNU General Public License for more details.
12
#
13
13
14
# You should have received a copy of the GNU General Public License
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
# This should really be an id randomly assigned when the tree is
23
# created, but it's not for now.
24
ROOT_ID = "TREE_ROOT"
25
26
27
import os.path
28
import re
29
import sys
30
import tarfile
31
import types
32
33
import bzrlib
34
from bzrlib.errors import BzrError, BzrCheckError
35
36
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
37
appendpath, sha_strings)
38
from bzrlib.trace import mutter
39
from bzrlib.errors import NotVersionedError
40
41
42
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.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):
43
38
"""Description of a versioned file.
44
39
45
40
An InventoryEntry has the following fields, which are also
46
41
present in the XML inventory-entry element:
47
42
48
file_id
49
50
name
51
(within the parent directory)
52
53
parent_id
54
file_id of the parent directory, or ROOT_ID
55
56
revision
57
the revision_id in which this variation of this file was
58
introduced.
59
60
executable
61
Indicates that this file should be executable on systems
62
that support it.
63
64
text_sha1
65
sha-1 of the text of the file
66
67
text_size
68
size in bytes of the text of the file
69
70
(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
71
57
72
58
>>> i = Inventory()
73
59
>>> i.path2id('')
74
'TREE_ROOT'
75
>>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
76
InventoryDirectory('123', 'src', parent_id='TREE_ROOT')
77
>>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
78
InventoryFile('2323', 'hello.c', parent_id='123')
60
>>> i.add(InventoryEntry('123', 'src', kind='directory'))
61
>>> i.add(InventoryEntry('2323', 'hello.c', parent_id='123'))
79
62
>>> for j in i.iter_entries():
80
63
... print j
81
64
...
82
('src', InventoryDirectory('123', 'src', parent_id='TREE_ROOT'))
83
('src/hello.c', InventoryFile('2323', 'hello.c', parent_id='123'))
84
>>> i.add(InventoryFile('2323', 'bye.c', '123'))
65
('src', InventoryEntry('123', 'src', kind='directory', parent_id=None))
66
('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
67
>>> i.add(InventoryEntry('2323', 'bye.c', parent_id='123'))
85
68
Traceback (most recent call last):
86
69
...
87
BzrError: inventory already contains entry with id {2323}
88
>>> i.add(InventoryFile('2324', 'bye.c', '123'))
89
InventoryFile('2324', 'bye.c', parent_id='123')
90
>>> i.add(InventoryDirectory('2325', 'wibble', '123'))
91
InventoryDirectory('2325', 'wibble', 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'))
92
73
>>> i.path2id('src/wibble')
93
74
'2325'
94
75
>>> '2325' in i
95
76
True
96
>>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
97
InventoryFile('2326', 'wibble.c', parent_id='2325')
77
>>> i.add(InventoryEntry('2326', 'wibble.c', parent_id='2325'))
98
78
>>> i['2326']
99
InventoryFile('2326', 'wibble.c', parent_id='2325')
100
>>> for path, entry in i.iter_entries():
101
... print path.replace('\\\\', '/') # for win32 os.sep
102
... assert i.path2id(path)
79
InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
80
>>> for j in i.iter_entries():
81
... print j[0]
82
... assert i.path2id(j[0])
103
83
...
104
84
src
105
85
src/bye.c
106
86
src/hello.c
107
87
src/wibble
108
88
src/wibble/wibble.c
109
>>> i.id2path('2326').replace('\\\\', '/')
89
>>> i.id2path('2326')
110
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.
111
95
"""
112
113
__slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
114
'text_id', 'parent_id', 'children', 'executable',
115
'revision']
116
117
def _add_text_to_weave(self, new_lines, parents, weave_store, transaction):
118
weave_store.add_text(self.file_id, self.revision, new_lines, parents,
119
transaction)
120
121
def detect_changes(self, old_entry):
122
"""Return a (text_modified, meta_modified) from this to old_entry.
123
124
_read_tree_state must have been called on self and old_entry prior to
125
calling detect_changes.
126
"""
127
return False, False
128
129
def diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
130
output_to, reverse=False):
131
"""Perform a diff from this to to_entry.
132
133
text_diff will be used for textual difference calculation.
134
This is a template method, override _diff in child classes.
135
"""
136
self._read_tree_state(tree)
137
if to_entry:
138
# cannot diff from one kind to another - you must do a removal
139
# and an addif they do not match.
140
assert self.kind == to_entry.kind
141
to_entry._read_tree_state(to_tree)
142
self._diff(text_diff, from_label, tree, to_label, to_entry, to_tree,
143
output_to, reverse)
144
145
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
146
output_to, reverse=False):
147
"""Perform a diff between two entries of the same kind."""
148
149
def find_previous_heads(self, previous_inventories, entry_weave):
150
"""Return the revisions and entries that directly preceed this.
151
152
Returned as a map from revision to inventory entry.
153
154
This is a map containing the file revisions in all parents
155
for which the file exists, and its revision is not a parent of
156
any other. If the file is new, the set will be empty.
157
"""
158
def get_ancestors(weave, entry):
159
return set(map(weave.idx_to_name,
160
weave.inclusions([weave.lookup(entry.revision)])))
161
heads = {}
162
head_ancestors = {}
163
for inv in previous_inventories:
164
if self.file_id in inv:
165
ie = inv[self.file_id]
166
assert ie.file_id == self.file_id
167
if ie.revision in heads:
168
# fixup logic, there was a bug in revision updates.
169
# with x bit support.
170
try:
171
if heads[ie.revision].executable != ie.executable:
172
heads[ie.revision].executable = False
173
ie.executable = False
174
except AttributeError:
175
pass
176
assert heads[ie.revision] == ie
177
else:
178
# may want to add it.
179
# may already be covered:
180
already_present = 0 != len(
181
[head for head in heads
182
if ie.revision in head_ancestors[head]])
183
if already_present:
184
# an ancestor of a known head.
185
continue
186
# definately a head:
187
ancestors = get_ancestors(entry_weave, ie)
188
# may knock something else out:
189
check_heads = list(heads.keys())
190
for head in check_heads:
191
if head in ancestors:
192
# this head is not really a head
193
heads.pop(head)
194
head_ancestors[ie.revision] = ancestors
195
heads[ie.revision] = ie
196
return heads
197
198
def get_tar_item(self, root, dp, now, tree):
199
"""Get a tarfile item and a file stream for its content."""
200
item = tarfile.TarInfo(os.path.join(root, dp))
201
# TODO: would be cool to actually set it to the timestamp of the
202
# revision it was last changed
203
item.mtime = now
204
fileobj = self._put_in_tar(item, tree)
205
return item, fileobj
206
207
def has_text(self):
208
"""Return true if the object this entry represents has textual data.
209
210
Note that textual data includes binary content.
211
212
Also note that all entries get weave files created for them.
213
This attribute is primarily used when upgrading from old trees that
214
did not have the weave index for all inventory entries.
215
"""
216
return False
217
218
def __init__(self, file_id, name, parent_id, text_id=None):
96
def __init__(self, file_id, name, kind='file', text_id=None,
97
parent_id=None):
219
98
"""Create an InventoryEntry
220
99
221
100
The filename must be a single component, relative to the
222
101
parent directory; it cannot be a whole path or relative name.
223
102
224
>>> e = InventoryFile('123', 'hello.c', ROOT_ID)
103
>>> e = InventoryEntry('123', 'hello.c')
225
104
>>> e.name
226
105
'hello.c'
227
106
>>> e.file_id
228
107
'123'
229
>>> e = InventoryFile('123', 'src/hello.c', ROOT_ID)
108
>>> e = InventoryEntry('123', 'src/hello.c')
230
109
Traceback (most recent call last):
231
BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
110
BzrError: ("InventoryEntry name is not a simple filename: 'src/hello.c'", [])
232
111
"""
233
assert isinstance(name, basestring), name
234
if '/' in name or '\\' in name:
235
raise BzrCheckError('InventoryEntry name %r is invalid' % name)
236
237
self.executable = False
238
self.revision = None
239
self.text_sha1 = None
240
self.text_size = None
112
113
if len(splitpath(name)) != 1:
114
bailout('InventoryEntry name is not a simple filename: %r'
115
% name)
116
241
117
self.file_id = file_id
242
118
self.name = name
119
assert kind in ['file', 'directory']
120
self.kind = kind
243
121
self.text_id = text_id
244
122
self.parent_id = parent_id
245
self.symlink_target = None
246
247
def kind_character(self):
248
"""Return a short kind indicator useful for appending to names."""
249
raise BzrError('unknown kind %r' % self.kind)
250
251
known_kinds = ('file', 'directory', 'symlink', 'root_directory')
252
253
def _put_in_tar(self, item, tree):
254
"""populate item for stashing in a tar, and return the content stream.
255
256
If no content is available, return None.
257
"""
258
raise BzrError("don't know how to export {%s} of kind %r" %
259
(self.file_id, self.kind))
260
261
def put_on_disk(self, dest, dp, tree):
262
"""Create a representation of self on disk in the prefix dest.
263
264
This is a template method - implement _put_on_disk in subclasses.
265
"""
266
fullpath = appendpath(dest, dp)
267
self._put_on_disk(fullpath, tree)
268
mutter(" export {%s} kind %s to %s" % (self.file_id, self.kind, fullpath))
269
270
def _put_on_disk(self, fullpath, tree):
271
"""Put this entry onto disk at fullpath, from tree tree."""
272
raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
273
274
def sorted_children(self):
275
l = self.children.items()
276
l.sort()
277
return l
278
279
@staticmethod
280
def versionable_kind(kind):
281
return kind in ('file', 'directory', 'symlink')
282
283
def check(self, checker, rev_id, inv, tree):
284
"""Check this inventory entry is intact.
285
286
This is a template method, override _check for kind specific
287
tests.
288
"""
289
if self.parent_id != None:
290
if not inv.has_id(self.parent_id):
291
raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
292
% (self.parent_id, rev_id))
293
self._check(checker, rev_id, tree)
294
295
def _check(self, checker, rev_id, tree):
296
"""Check this inventory entry for kind specific errors."""
297
raise BzrCheckError('unknown entry kind %r in revision {%s}' %
298
(self.kind, rev_id))
123
self.text_sha1 = None
124
self.text_size = None
299
125
300
126
301
127
def copy(self):
302
"""Clone this inventory entry."""
303
raise NotImplementedError
128
other = InventoryEntry(self.file_id, self.name, self.kind,
129
self.text_id, self.parent_id)
130
other.text_sha1 = self.text_sha1
131
other.text_size = self.text_size
132
return other
304
133
305
def _get_snapshot_change(self, previous_entries):
306
if len(previous_entries) > 1:
307
return 'merged'
308
elif len(previous_entries) == 0:
309
return 'added'
310
else:
311
return 'modified/renamed/reparented'
312
134
313
135
def __repr__(self):
314
return ("%s(%r, %r, parent_id=%r)"
136
return ("%s(%r, %r, kind=%r, parent_id=%r)"
315
137
% (self.__class__.__name__,
316
138
self.file_id,
317
139
self.name,
140
self.kind,
318
141
self.parent_id))
319
142
320
def snapshot(self, revision, path, previous_entries,
321
work_tree, weave_store, transaction):
322
"""Make a snapshot of this entry which may or may not have changed.
323
324
This means that all its fields are populated, that it has its
325
text stored in the text store or weave.
326
"""
327
mutter('new parents of %s are %r', path, previous_entries)
328
self._read_tree_state(work_tree)
329
if len(previous_entries) == 1:
330
# cannot be unchanged unless there is only one parent file rev.
331
parent_ie = previous_entries.values()[0]
332
if self._unchanged(parent_ie):
333
mutter("found unchanged entry")
334
self.revision = parent_ie.revision
335
return "unchanged"
336
return self.snapshot_revision(revision, previous_entries,
337
work_tree, weave_store, transaction)
338
339
def snapshot_revision(self, revision, previous_entries, work_tree,
340
weave_store, transaction):
341
"""Record this revision unconditionally."""
342
mutter('new revision for {%s}', self.file_id)
343
self.revision = revision
344
change = self._get_snapshot_change(previous_entries)
345
self._snapshot_text(previous_entries, work_tree, weave_store,
346
transaction)
347
return change
348
349
def _snapshot_text(self, file_parents, work_tree, weave_store, transaction):
350
"""Record the 'text' of this entry, whatever form that takes.
351
352
This default implementation simply adds an empty text.
353
"""
354
mutter('storing file {%s} in revision {%s}',
355
self.file_id, self.revision)
356
self._add_text_to_weave([], file_parents, weave_store, transaction)
357
358
def __eq__(self, other):
143
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
359
185
if not isinstance(other, InventoryEntry):
360
186
return NotImplemented
361
187
362
return ((self.file_id == other.file_id)
363
and (self.name == other.name)
364
and (other.symlink_target == self.symlink_target)
365
and (self.text_sha1 == other.text_sha1)
366
and (self.text_size == other.text_size)
367
and (self.text_id == other.text_id)
368
and (self.parent_id == other.parent_id)
369
and (self.kind == other.kind)
370
and (self.revision == other.revision)
371
and (self.executable == other.executable)
372
)
373
374
def __ne__(self, other):
375
return not (self == other)
376
377
def __hash__(self):
378
raise ValueError('not hashable')
379
380
def _unchanged(self, previous_ie):
381
"""Has this entry changed relative to previous_ie.
382
383
This method should be overriden in child classes.
384
"""
385
compatible = True
386
# different inv parent
387
if previous_ie.parent_id != self.parent_id:
388
compatible = False
389
# renamed
390
elif previous_ie.name != self.name:
391
compatible = False
392
return compatible
393
394
def _read_tree_state(self, work_tree):
395
"""Populate fields in the inventory entry from the given tree.
396
397
Note that this should be modified to be a noop on virtual trees
398
as all entries created there are prepopulated.
399
"""
400
# TODO: Rather than running this manually, we should check the
401
# working sha1 and other expensive properties when they're
402
# first requested, or preload them if they're already known
403
pass # nothing to do by default
404
405
406
class RootEntry(InventoryEntry):
407
408
def _check(self, checker, rev_id, tree):
409
"""See InventoryEntry._check"""
410
411
def __init__(self, file_id):
412
self.file_id = file_id
413
self.children = {}
414
self.kind = 'root_directory'
415
self.parent_id = None
416
self.name = ''
417
418
def __eq__(self, other):
419
if not isinstance(other, RootEntry):
420
return NotImplemented
421
422
return (self.file_id == other.file_id) \
423
and (self.children == other.children)
424
425
426
class InventoryDirectory(InventoryEntry):
427
"""A directory in an inventory."""
428
429
def _check(self, checker, rev_id, tree):
430
"""See InventoryEntry._check"""
431
if self.text_sha1 != None or self.text_size != None or self.text_id != None:
432
raise BzrCheckError('directory {%s} has text in revision {%s}'
433
% (self.file_id, rev_id))
434
435
def copy(self):
436
other = InventoryDirectory(self.file_id, self.name, self.parent_id)
437
other.revision = self.revision
438
# note that children are *not* copied; they're pulled across when
439
# others are added
440
return other
441
442
def __init__(self, file_id, name, parent_id):
443
super(InventoryDirectory, self).__init__(file_id, name, parent_id)
444
self.children = {}
445
self.kind = 'directory'
446
447
def kind_character(self):
448
"""See InventoryEntry.kind_character."""
449
return '/'
450
451
def _put_in_tar(self, item, tree):
452
"""See InventoryEntry._put_in_tar."""
453
item.type = tarfile.DIRTYPE
454
fileobj = None
455
item.name += '/'
456
item.size = 0
457
item.mode = 0755
458
return fileobj
459
460
def _put_on_disk(self, fullpath, tree):
461
"""See InventoryEntry._put_on_disk."""
462
os.mkdir(fullpath)
463
464
465
class InventoryFile(InventoryEntry):
466
"""A file in an inventory."""
467
468
def _check(self, checker, rev_id, tree):
469
"""See InventoryEntry._check"""
470
revision = self.revision
471
t = (self.file_id, revision)
472
if t in checker.checked_texts:
473
prev_sha = checker.checked_texts[t]
474
if prev_sha != self.text_sha1:
475
raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
476
(self.file_id, rev_id))
477
else:
478
checker.repeated_text_cnt += 1
479
return
480
mutter('check version {%s} of {%s}', rev_id, self.file_id)
481
file_lines = tree.get_file_lines(self.file_id)
482
checker.checked_text_cnt += 1
483
if self.text_size != sum(map(len, file_lines)):
484
raise BzrCheckError('text {%s} wrong size' % self.text_id)
485
if self.text_sha1 != sha_strings(file_lines):
486
raise BzrCheckError('text {%s} wrong sha1' % self.text_id)
487
checker.checked_texts[t] = self.text_sha1
488
489
def copy(self):
490
other = InventoryFile(self.file_id, self.name, self.parent_id)
491
other.executable = self.executable
492
other.text_id = self.text_id
493
other.text_sha1 = self.text_sha1
494
other.text_size = self.text_size
495
other.revision = self.revision
496
return other
497
498
def detect_changes(self, old_entry):
499
"""See InventoryEntry.detect_changes."""
500
assert self.text_sha1 != None
501
assert old_entry.text_sha1 != None
502
text_modified = (self.text_sha1 != old_entry.text_sha1)
503
meta_modified = (self.executable != old_entry.executable)
504
return text_modified, meta_modified
505
506
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
507
output_to, reverse=False):
508
"""See InventoryEntry._diff."""
509
from_text = tree.get_file(self.file_id).readlines()
510
if to_entry:
511
to_text = to_tree.get_file(to_entry.file_id).readlines()
512
else:
513
to_text = []
514
if not reverse:
515
text_diff(from_label, from_text,
516
to_label, to_text, output_to)
517
else:
518
text_diff(to_label, to_text,
519
from_label, from_text, output_to)
520
521
def has_text(self):
522
"""See InventoryEntry.has_text."""
523
return True
524
525
def __init__(self, file_id, name, parent_id):
526
super(InventoryFile, self).__init__(file_id, name, parent_id)
527
self.kind = 'file'
528
529
def kind_character(self):
530
"""See InventoryEntry.kind_character."""
531
return ''
532
533
def _put_in_tar(self, item, tree):
534
"""See InventoryEntry._put_in_tar."""
535
item.type = tarfile.REGTYPE
536
fileobj = tree.get_file(self.file_id)
537
item.size = self.text_size
538
if tree.is_executable(self.file_id):
539
item.mode = 0755
540
else:
541
item.mode = 0644
542
return fileobj
543
544
def _put_on_disk(self, fullpath, tree):
545
"""See InventoryEntry._put_on_disk."""
546
pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
547
if tree.is_executable(self.file_id):
548
os.chmod(fullpath, 0755)
549
550
def _read_tree_state(self, work_tree):
551
"""See InventoryEntry._read_tree_state."""
552
self.text_sha1 = work_tree.get_file_sha1(self.file_id)
553
self.executable = work_tree.is_executable(self.file_id)
554
555
def _snapshot_text(self, file_parents, work_tree, weave_store, transaction):
556
"""See InventoryEntry._snapshot_text."""
557
mutter('storing file {%s} in revision {%s}',
558
self.file_id, self.revision)
559
# special case to avoid diffing on renames or
560
# reparenting
561
if (len(file_parents) == 1
562
and self.text_sha1 == file_parents.values()[0].text_sha1
563
and self.text_size == file_parents.values()[0].text_size):
564
previous_ie = file_parents.values()[0]
565
weave_store.add_identical_text(
566
self.file_id, previous_ie.revision,
567
self.revision, file_parents, transaction)
568
else:
569
new_lines = work_tree.get_file(self.file_id).readlines()
570
self._add_text_to_weave(new_lines, file_parents, weave_store,
571
transaction)
572
self.text_sha1 = sha_strings(new_lines)
573
self.text_size = sum(map(len, new_lines))
574
575
576
def _unchanged(self, previous_ie):
577
"""See InventoryEntry._unchanged."""
578
compatible = super(InventoryFile, self)._unchanged(previous_ie)
579
if self.text_sha1 != previous_ie.text_sha1:
580
compatible = False
581
else:
582
# FIXME: 20050930 probe for the text size when getting sha1
583
# in _read_tree_state
584
self.text_size = previous_ie.text_size
585
if self.executable != previous_ie.executable:
586
compatible = False
587
return compatible
588
589
590
class InventoryLink(InventoryEntry):
591
"""A file in an inventory."""
592
593
__slots__ = ['symlink_target']
594
595
def _check(self, checker, rev_id, tree):
596
"""See InventoryEntry._check"""
597
if self.text_sha1 != None or self.text_size != None or self.text_id != None:
598
raise BzrCheckError('symlink {%s} has text in revision {%s}'
599
% (self.file_id, rev_id))
600
if self.symlink_target == None:
601
raise BzrCheckError('symlink {%s} has no target in revision {%s}'
602
% (self.file_id, rev_id))
603
604
def copy(self):
605
other = InventoryLink(self.file_id, self.name, self.parent_id)
606
other.symlink_target = self.symlink_target
607
other.revision = self.revision
608
return other
609
610
def detect_changes(self, old_entry):
611
"""See InventoryEntry.detect_changes."""
612
# FIXME: which _modified field should we use ? RBC 20051003
613
text_modified = (self.symlink_target != old_entry.symlink_target)
614
if text_modified:
615
mutter(" symlink target changed")
616
meta_modified = False
617
return text_modified, meta_modified
618
619
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
620
output_to, reverse=False):
621
"""See InventoryEntry._diff."""
622
from_text = self.symlink_target
623
if to_entry is not None:
624
to_text = to_entry.symlink_target
625
if reverse:
626
temp = from_text
627
from_text = to_text
628
to_text = temp
629
print >>output_to, '=== target changed %r => %r' % (from_text, to_text)
630
else:
631
if not reverse:
632
print >>output_to, '=== target was %r' % self.symlink_target
633
else:
634
print >>output_to, '=== target is %r' % self.symlink_target
635
636
def __init__(self, file_id, name, parent_id):
637
super(InventoryLink, self).__init__(file_id, name, parent_id)
638
self.kind = 'symlink'
639
640
def kind_character(self):
641
"""See InventoryEntry.kind_character."""
642
return ''
643
644
def _put_in_tar(self, item, tree):
645
"""See InventoryEntry._put_in_tar."""
646
iterm.type = tarfile.SYMTYPE
647
fileobj = None
648
item.size = 0
649
item.mode = 0755
650
item.linkname = self.symlink_target
651
return fileobj
652
653
def _put_on_disk(self, fullpath, tree):
654
"""See InventoryEntry._put_on_disk."""
655
try:
656
os.symlink(self.symlink_target, fullpath)
657
except OSError,e:
658
raise BzrError("Failed to create symlink %r -> %r, error: %s" % (fullpath, self.symlink_target, e))
659
660
def _read_tree_state(self, work_tree):
661
"""See InventoryEntry._read_tree_state."""
662
self.symlink_target = work_tree.get_symlink_target(self.file_id)
663
664
def _unchanged(self, previous_ie):
665
"""See InventoryEntry._unchanged."""
666
compatible = super(InventoryLink, self)._unchanged(previous_ie)
667
if self.symlink_target != previous_ie.symlink_target:
668
compatible = False
669
return compatible
670
671
672
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):
673
199
"""Inventory of versioned files in a tree.
674
200
675
This describes which file_id is present at each point in the tree,
676
and possibly the SHA-1 or other information about the file.
677
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.
678
207
679
208
The inventory represents a typical unix file tree, with
680
209
directories containing files and subdirectories. We never store
684
213
returned quickly.
685
214
686
215
InventoryEntry objects must not be modified after they are
687
inserted, other than through the Inventory API.
216
inserted.
688
217
689
218
>>> inv = Inventory()
690
>>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
691
InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
219
>>> inv.write_xml(sys.stdout)
220
<inventory>
221
</inventory>
222
>>> inv.add(InventoryEntry('123-123', 'hello.c'))
692
223
>>> inv['123-123'].name
693
224
'hello.c'
225
>>> for file_id in inv: print file_id
226
...
227
123-123
694
228
695
229
May be treated as an iterator or set to look up file ids:
696
230
703
237
704
238
>>> [x[0] for x in inv.iter_entries()]
705
239
['hello.c']
706
>>> inv = Inventory('TREE_ROOT-12345678-12345678')
707
>>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
708
InventoryFile('123-123', 'hello.c', 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
709
246
"""
710
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):
711
262
"""Create or read an inventory.
712
263
713
264
If a working directory is specified, the inventory is read
714
265
from there. If the file is specified, read from that. If not,
715
266
the inventory is created empty.
716
717
The inventory is created with a default root directory, with
718
an id of None.
719
267
"""
720
# We are letting Branch.initialize() create a unique inventory
721
# root id. Rather than generating a random one here.
722
#if root_id is None:
723
# root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
724
self.root = RootEntry(root_id)
725
self._byid = {self.root.file_id: self.root}
726
727
728
def copy(self):
729
other = Inventory(self.root.file_id)
730
# copy recursively so we know directories will be added before
731
# their children. There are more efficient ways than this...
732
for path, entry in self.iter_entries():
733
if entry == self.root:
734
continue
735
other.add(entry.copy())
736
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: {}}
737
273
738
274
739
275
def __iter__(self):
745
281
return len(self._byid)
746
282
747
283
748
def iter_entries(self, from_dir=None):
284
def iter_entries(self, parent_id=None):
749
285
"""Return (path, entry) pairs, in order by name."""
750
if from_dir == None:
751
assert self.root
752
from_dir = self.root
753
elif isinstance(from_dir, basestring):
754
from_dir = self._byid[from_dir]
755
756
kids = from_dir.children.items()
286
kids = self._tree[parent_id].items()
757
287
kids.sort()
758
288
for name, ie in kids:
759
289
yield name, ie
760
290
if ie.kind == 'directory':
761
for cn, cie in self.iter_entries(from_dir=ie.file_id):
762
yield os.path.join(name, cn), cie
763
764
765
def entries(self):
766
"""Return list of (path, ie) for all entries except the root.
767
768
This may be faster than iter_entries.
769
"""
770
accum = []
771
def descend(dir_ie, dir_path):
772
kids = dir_ie.children.items()
773
kids.sort()
774
for name, ie in kids:
775
child_path = os.path.join(dir_path, name)
776
accum.append((child_path, ie))
777
if ie.kind == 'directory':
778
descend(ie, child_path)
779
780
descend(self.root, '')
781
return accum
782
783
784
def directories(self):
785
"""Return (path, entry) pairs for all directories, including the root.
786
"""
787
accum = []
788
def descend(parent_ie, parent_path):
789
accum.append((parent_path, parent_ie))
790
791
kids = [(ie.name, ie) for ie in parent_ie.children.itervalues() if ie.kind == 'directory']
792
kids.sort()
793
794
for name, child_ie in kids:
795
child_path = os.path.join(parent_path, name)
796
descend(child_ie, child_path)
797
descend(self.root, '')
798
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
799
303
800
304
801
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
802
315
def __contains__(self, file_id):
803
316
"""True if this entry contains a file with given id.
804
317
805
318
>>> inv = Inventory()
806
>>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
807
InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
319
>>> inv.add(InventoryEntry('123', 'foo.c'))
808
320
>>> '123' in inv
809
321
True
810
322
>>> '456' in inv
817
329
"""Return the entry for given file_id.
818
330
819
331
>>> inv = Inventory()
820
>>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
821
InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
332
>>> inv.add(InventoryEntry('123123', 'hello.c'))
822
333
>>> inv['123123'].name
823
334
'hello.c'
824
335
"""
825
try:
826
return self._byid[file_id]
827
except KeyError:
828
if file_id == None:
829
raise BzrError("can't look up file_id None")
830
else:
831
raise BzrError("file_id {%s} not in inventory" % file_id)
832
833
834
def get_file_kind(self, file_id):
835
return self._byid[file_id].kind
836
837
def get_child(self, parent_id, filename):
838
return self[parent_id].children.get(filename)
336
return self._byid[file_id]
839
337
840
338
841
339
def add(self, entry):
842
340
"""Add entry to inventory.
843
341
844
342
To add a file to a branch ready to be committed, use Branch.add,
845
which calls this.
846
847
Returns the new entry object.
848
"""
849
if entry.file_id in self._byid:
850
raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
851
852
if entry.parent_id == ROOT_ID or entry.parent_id is None:
853
entry.parent_id = self.root.file_id
854
855
try:
856
parent = self._byid[entry.parent_id]
857
except KeyError:
858
raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
859
860
if parent.children.has_key(entry.name):
861
raise BzrError("%s is already versioned" %
862
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))
863
355
864
356
self._byid[entry.file_id] = entry
865
parent.children[entry.name] = entry
866
return entry
867
868
869
def add_path(self, relpath, kind, file_id=None):
870
"""Add entry from a path.
871
872
The immediate parent must already be versioned.
873
874
Returns the new entry object."""
875
from bzrlib.branch import gen_file_id
876
877
parts = bzrlib.osutils.splitpath(relpath)
878
if len(parts) == 0:
879
raise BzrError("cannot re-add root of inventory")
880
881
if file_id == None:
882
file_id = gen_file_id(relpath)
883
884
parent_path = parts[:-1]
885
parent_id = self.path2id(parent_path)
886
if parent_id == None:
887
raise NotVersionedError(parent_path)
888
889
if kind == 'directory':
890
ie = InventoryDirectory(file_id, parts[-1], parent_id)
891
elif kind == 'file':
892
ie = InventoryFile(file_id, parts[-1], parent_id)
893
elif kind == 'symlink':
894
ie = InventoryLink(file_id, parts[-1], parent_id)
895
else:
896
raise BzrError("unknown kind %r" % kind)
897
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] = {}
898
361
899
362
900
363
def __delitem__(self, file_id):
901
364
"""Remove entry by id.
902
365
903
366
>>> inv = Inventory()
904
>>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
905
InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
367
>>> inv.add(InventoryEntry('123', 'foo.c'))
906
368
>>> '123' in inv
907
369
True
908
370
>>> del inv['123']
911
373
"""
912
374
ie = self[file_id]
913
375
914
assert self[ie.parent_id].children[ie.name] == ie
376
assert self._tree[ie.parent_id][ie.name] == ie
915
377
916
378
# TODO: Test deleting all children; maybe hoist to a separate
917
379
# deltree method?
918
380
if ie.kind == 'directory':
919
for cie in ie.children.values():
381
for cie in self._tree[file_id].values():
920
382
del self[cie.file_id]
921
del ie.children
383
del self._tree[file_id]
922
384
923
385
del self._byid[file_id]
924
del self[ie.parent_id].children[ie.name]
925
926
927
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):
928
422
"""Compare two sets by comparing their contents.
929
423
930
424
>>> i1 = Inventory()
931
425
>>> i2 = Inventory()
932
426
>>> i1 == i2
933
427
True
934
>>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
935
InventoryFile('123', 'foo', parent_id='TREE_ROOT')
428
>>> i1.add(InventoryEntry('123', 'foo'))
936
429
>>> i1 == i2
937
430
False
938
>>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
939
InventoryFile('123', 'foo', parent_id='TREE_ROOT')
431
>>> i2.add(InventoryEntry('123', 'foo'))
940
432
>>> i1 == i2
941
433
True
942
434
"""
435
if self is other:
436
return 0
437
943
438
if not isinstance(other, Inventory):
944
439
return NotImplemented
945
440
946
if len(self._byid) != len(other._byid):
947
# shortcut: obviously not the same
948
return False
949
950
return self._byid == other._byid
951
952
953
def __ne__(self, other):
954
return not self.__eq__(other)
955
956
957
def __hash__(self):
958
raise ValueError('not hashable')
959
960
961
def get_idpath(self, file_id):
962
"""Return a list of file_ids for the path to an entry.
963
964
The list contains one element for each directory followed by
965
the id of the file itself. So the length of the returned list
966
is equal to the depth of the file in the tree, counting the
967
root directory as depth 1.
968
"""
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."""
969
453
p = []
970
454
while file_id != None:
971
try:
972
ie = self._byid[file_id]
973
except KeyError:
974
raise BzrError("file_id {%s} not found in inventory" % file_id)
975
p.insert(0, ie.file_id)
455
ie = self[file_id]
456
p = [ie.name] + p
976
457
file_id = ie.parent_id
977
return p
978
979
980
def id2path(self, file_id):
981
"""Return as a list the path to file_id.
982
983
>>> i = Inventory()
984
>>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))
985
>>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))
986
>>> print i.id2path('foo-id').replace(os.sep, '/')
987
src/foo.c
988
"""
989
# get all names, skipping root
990
p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
991
return os.sep.join(p)
458
return joinpath(p)
992
459
993
460
994
461
1000
467
1001
468
This returns the entry of the last component in the path,
1002
469
which may be either a file or a directory.
1003
1004
Returns None iff the path is not found.
1005
470
"""
1006
if isinstance(name, types.StringTypes):
1007
name = splitpath(name)
1008
1009
mutter("lookup path %r" % name)
1010
1011
parent = self.root
1012
for f in name:
471
assert isinstance(name, types.StringTypes)
472
473
parent_id = None
474
for f in splitpath(name):
1013
475
try:
1014
cie = parent.children[f]
476
cie = self._tree[parent_id][f]
1015
477
assert cie.name == f
1016
assert cie.parent_id == parent.file_id
1017
parent = cie
478
parent_id = cie.file_id
1018
479
except KeyError:
1019
480
# or raise an error?
1020
481
return None
1021
482
1022
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)
1023
488
1024
489
1025
490
def has_filename(self, names):
1027
492
1028
493
1029
494
def has_id(self, file_id):
495
assert isinstance(file_id, str)
1030
496
return self._byid.has_key(file_id)
1031
497
1032
498
1033
def rename(self, file_id, new_parent_id, new_name):
1034
"""Move a file within the inventory.
1035
1036
This can change either the name, or the parent, or both.
1037
1038
This does not move the working file."""
1039
if not is_valid_name(new_name):
1040
raise BzrError("not an acceptable filename: %r" % new_name)
1041
1042
new_parent = self._byid[new_parent_id]
1043
if new_name in new_parent.children:
1044
raise BzrError("%r already exists in %r" % (new_name, self.id2path(new_parent_id)))
1045
1046
new_parent_idpath = self.get_idpath(new_parent_id)
1047
if file_id in new_parent_idpath:
1048
raise BzrError("cannot move directory %r into a subdirectory of itself, %r"
1049
% (self.id2path(file_id), self.id2path(new_parent_id)))
1050
1051
file_ie = self._byid[file_id]
1052
old_parent = self._byid[file_ie.parent_id]
1053
1054
# TODO: Don't leave things messed up if this fails
1055
1056
del old_parent.children[file_ie.name]
1057
new_parent.children[new_name] = file_ie
1058
1059
file_ie.name = new_name
1060
file_ie.parent_id = new_parent_id
1061
1062
1063
1064
1065
_NAME_RE = None
1066
1067
def is_valid_name(name):
1068
global _NAME_RE
1069
if _NAME_RE == None:
1070
_NAME_RE = re.compile(r'^[^/\\]+$')
1071
1072
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