« back to all changes in this revision
Viewing changes to bzrlib/inventory.py
- browse files at revision 1449
- compare with another revision
- download diff
- download tarball
- view history from revision 1449
- Committer: Robert Collins
- Date: 2005-10-13 01:29:22 UTC
- Revision ID: robertc@lifelesslap.robertcollins.net-20051013012922-b0249adeccecc4ed
teach check about ghosts
- files added:
- .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 removed:
- bzrlib/tests.py
- files renamed:
- bzrlib/store.py => bzrlib/store/__init__.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/inventory.py
1
#! /usr/bin/env python
2
# -*- coding: UTF-8 -*-
3
1
# (C) 2005 Canonical Ltd
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
6
5
# the Free Software Foundation; either version 2 of the License, or
7
6
# (at your option) any later version.
8
7
#
9
8
# This program is distributed in the hope that it will be useful,
10
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
11
# GNU General Public License for more details.
13
12
#
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
16
18
"""Inventories map files to their name in a revision."""
19
20
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):
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):
38
43
"""Description of a versioned file.
39
44
40
45
An InventoryEntry has the following fields, which are also
41
46
present in the XML inventory-entry element:
42
47
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
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.)
57
71
58
72
>>> i = Inventory()
59
73
>>> i.path2id('')
60
>>> i.add(InventoryEntry('123', 'src', kind='directory'))
61
>>> i.add(InventoryEntry('2323', 'hello.c', parent_id='123'))
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')
62
79
>>> for j in i.iter_entries():
63
80
... print j
64
81
...
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'))
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'))
68
85
Traceback (most recent call last):
69
86
...
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'))
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')
73
92
>>> i.path2id('src/wibble')
74
93
'2325'
75
94
>>> '2325' in i
76
95
True
77
>>> i.add(InventoryEntry('2326', 'wibble.c', parent_id='2325'))
96
>>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
97
InventoryFile('2326', 'wibble.c', parent_id='2325')
78
98
>>> i['2326']
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])
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)
83
103
...
84
104
src
85
105
src/bye.c
86
106
src/hello.c
87
107
src/wibble
88
108
src/wibble/wibble.c
89
>>> i.id2path('2326')
109
>>> i.id2path('2326').replace('\\\\', '/')
90
110
'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.
95
111
"""
96
def __init__(self, file_id, name, kind='file', text_id=None,
97
parent_id=None):
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):
98
219
"""Create an InventoryEntry
99
220
100
221
The filename must be a single component, relative to the
101
222
parent directory; it cannot be a whole path or relative name.
102
223
103
>>> e = InventoryEntry('123', 'hello.c')
224
>>> e = InventoryFile('123', 'hello.c', ROOT_ID)
104
225
>>> e.name
105
226
'hello.c'
106
227
>>> e.file_id
107
228
'123'
108
>>> e = InventoryEntry('123', 'src/hello.c')
229
>>> e = InventoryFile('123', 'src/hello.c', ROOT_ID)
109
230
Traceback (most recent call last):
110
BzrError: ("InventoryEntry name is not a simple filename: 'src/hello.c'", [])
231
BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
111
232
"""
112
113
if len(splitpath(name)) != 1:
114
bailout('InventoryEntry name is not a simple filename: %r'
115
% name)
116
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
117
241
self.file_id = file_id
118
242
self.name = name
119
assert kind in ['file', 'directory']
120
self.kind = kind
121
243
self.text_id = text_id
122
244
self.parent_id = parent_id
123
self.text_sha1 = None
124
self.text_size = None
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))
125
299
126
300
127
301
def copy(self):
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
302
"""Clone this inventory entry."""
303
raise NotImplementedError
133
304
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'
134
312
135
313
def __repr__(self):
136
return ("%s(%r, %r, kind=%r, parent_id=%r)"
314
return ("%s(%r, %r, parent_id=%r)"
137
315
% (self.__class__.__name__,
138
316
self.file_id,
139
317
self.name,
140
self.kind,
141
318
self.parent_id))
142
319
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
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):
185
359
if not isinstance(other, InventoryEntry):
186
360
return NotImplemented
187
361
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):
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
401
402
class RootEntry(InventoryEntry):
403
404
def _check(self, checker, rev_id, tree):
405
"""See InventoryEntry._check"""
406
407
def __init__(self, file_id):
408
self.file_id = file_id
409
self.children = {}
410
self.kind = 'root_directory'
411
self.parent_id = None
412
self.name = ''
413
414
def __eq__(self, other):
415
if not isinstance(other, RootEntry):
416
return NotImplemented
417
418
return (self.file_id == other.file_id) \
419
and (self.children == other.children)
420
421
422
class InventoryDirectory(InventoryEntry):
423
"""A directory in an inventory."""
424
425
def _check(self, checker, rev_id, tree):
426
"""See InventoryEntry._check"""
427
if self.text_sha1 != None or self.text_size != None or self.text_id != None:
428
raise BzrCheckError('directory {%s} has text in revision {%s}'
429
% (self.file_id, rev_id))
430
431
def copy(self):
432
other = InventoryDirectory(self.file_id, self.name, self.parent_id)
433
other.revision = self.revision
434
# note that children are *not* copied; they're pulled across when
435
# others are added
436
return other
437
438
def __init__(self, file_id, name, parent_id):
439
super(InventoryDirectory, self).__init__(file_id, name, parent_id)
440
self.children = {}
441
self.kind = 'directory'
442
443
def kind_character(self):
444
"""See InventoryEntry.kind_character."""
445
return '/'
446
447
def _put_in_tar(self, item, tree):
448
"""See InventoryEntry._put_in_tar."""
449
item.type = tarfile.DIRTYPE
450
fileobj = None
451
item.name += '/'
452
item.size = 0
453
item.mode = 0755
454
return fileobj
455
456
def _put_on_disk(self, fullpath, tree):
457
"""See InventoryEntry._put_on_disk."""
458
os.mkdir(fullpath)
459
460
461
class InventoryFile(InventoryEntry):
462
"""A file in an inventory."""
463
464
def _check(self, checker, rev_id, tree):
465
"""See InventoryEntry._check"""
466
revision = self.revision
467
t = (self.file_id, revision)
468
if t in checker.checked_texts:
469
prev_sha = checker.checked_texts[t]
470
if prev_sha != self.text_sha1:
471
raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
472
(self.file_id, rev_id))
473
else:
474
checker.repeated_text_cnt += 1
475
return
476
mutter('check version {%s} of {%s}', rev_id, self.file_id)
477
file_lines = tree.get_file_lines(self.file_id)
478
checker.checked_text_cnt += 1
479
if self.text_size != sum(map(len, file_lines)):
480
raise BzrCheckError('text {%s} wrong size' % self.text_id)
481
if self.text_sha1 != sha_strings(file_lines):
482
raise BzrCheckError('text {%s} wrong sha1' % self.text_id)
483
checker.checked_texts[t] = self.text_sha1
484
485
def copy(self):
486
other = InventoryFile(self.file_id, self.name, self.parent_id)
487
other.executable = self.executable
488
other.text_id = self.text_id
489
other.text_sha1 = self.text_sha1
490
other.text_size = self.text_size
491
other.revision = self.revision
492
return other
493
494
def detect_changes(self, old_entry):
495
"""See InventoryEntry.detect_changes."""
496
assert self.text_sha1 != None
497
assert old_entry.text_sha1 != None
498
text_modified = (self.text_sha1 != old_entry.text_sha1)
499
meta_modified = (self.executable != old_entry.executable)
500
return text_modified, meta_modified
501
502
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
503
output_to, reverse=False):
504
"""See InventoryEntry._diff."""
505
from_text = tree.get_file(self.file_id).readlines()
506
if to_entry:
507
to_text = to_tree.get_file(to_entry.file_id).readlines()
508
else:
509
to_text = []
510
if not reverse:
511
text_diff(from_label, from_text,
512
to_label, to_text, output_to)
513
else:
514
text_diff(to_label, to_text,
515
from_label, from_text, output_to)
516
517
def has_text(self):
518
"""See InventoryEntry.has_text."""
519
return True
520
521
def __init__(self, file_id, name, parent_id):
522
super(InventoryFile, self).__init__(file_id, name, parent_id)
523
self.kind = 'file'
524
525
def kind_character(self):
526
"""See InventoryEntry.kind_character."""
527
return ''
528
529
def _put_in_tar(self, item, tree):
530
"""See InventoryEntry._put_in_tar."""
531
item.type = tarfile.REGTYPE
532
fileobj = tree.get_file(self.file_id)
533
item.size = self.text_size
534
if tree.is_executable(self.file_id):
535
item.mode = 0755
536
else:
537
item.mode = 0644
538
return fileobj
539
540
def _put_on_disk(self, fullpath, tree):
541
"""See InventoryEntry._put_on_disk."""
542
pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
543
if tree.is_executable(self.file_id):
544
os.chmod(fullpath, 0755)
545
546
def _read_tree_state(self, work_tree):
547
"""See InventoryEntry._read_tree_state."""
548
self.text_sha1 = work_tree.get_file_sha1(self.file_id)
549
self.executable = work_tree.is_executable(self.file_id)
550
551
def _snapshot_text(self, file_parents, work_tree, weave_store, transaction):
552
"""See InventoryEntry._snapshot_text."""
553
mutter('storing file {%s} in revision {%s}',
554
self.file_id, self.revision)
555
# special case to avoid diffing on renames or
556
# reparenting
557
if (len(file_parents) == 1
558
and self.text_sha1 == file_parents.values()[0].text_sha1
559
and self.text_size == file_parents.values()[0].text_size):
560
previous_ie = file_parents.values()[0]
561
weave_store.add_identical_text(
562
self.file_id, previous_ie.revision,
563
self.revision, file_parents, transaction)
564
else:
565
new_lines = work_tree.get_file(self.file_id).readlines()
566
self._add_text_to_weave(new_lines, file_parents, weave_store,
567
transaction)
568
self.text_sha1 = sha_strings(new_lines)
569
self.text_size = sum(map(len, new_lines))
570
571
572
def _unchanged(self, previous_ie):
573
"""See InventoryEntry._unchanged."""
574
compatible = super(InventoryFile, self)._unchanged(previous_ie)
575
if self.text_sha1 != previous_ie.text_sha1:
576
compatible = False
577
else:
578
# FIXME: 20050930 probe for the text size when getting sha1
579
# in _read_tree_state
580
self.text_size = previous_ie.text_size
581
if self.executable != previous_ie.executable:
582
compatible = False
583
return compatible
584
585
586
class InventoryLink(InventoryEntry):
587
"""A file in an inventory."""
588
589
__slots__ = ['symlink_target']
590
591
def _check(self, checker, rev_id, tree):
592
"""See InventoryEntry._check"""
593
if self.text_sha1 != None or self.text_size != None or self.text_id != None:
594
raise BzrCheckError('symlink {%s} has text in revision {%s}'
595
% (self.file_id, rev_id))
596
if self.symlink_target == None:
597
raise BzrCheckError('symlink {%s} has no target in revision {%s}'
598
% (self.file_id, rev_id))
599
600
def copy(self):
601
other = InventoryLink(self.file_id, self.name, self.parent_id)
602
other.symlink_target = self.symlink_target
603
other.revision = self.revision
604
return other
605
606
def detect_changes(self, old_entry):
607
"""See InventoryEntry.detect_changes."""
608
# FIXME: which _modified field should we use ? RBC 20051003
609
text_modified = (self.symlink_target != old_entry.symlink_target)
610
if text_modified:
611
mutter(" symlink target changed")
612
meta_modified = False
613
return text_modified, meta_modified
614
615
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
616
output_to, reverse=False):
617
"""See InventoryEntry._diff."""
618
from_text = self.symlink_target
619
if to_entry is not None:
620
to_text = to_entry.symlink_target
621
if reverse:
622
temp = from_text
623
from_text = to_text
624
to_text = temp
625
print >>output_to, '=== target changed %r => %r' % (from_text, to_text)
626
else:
627
if not reverse:
628
print >>output_to, '=== target was %r' % self.symlink_target
629
else:
630
print >>output_to, '=== target is %r' % self.symlink_target
631
632
def __init__(self, file_id, name, parent_id):
633
super(InventoryLink, self).__init__(file_id, name, parent_id)
634
self.kind = 'symlink'
635
636
def kind_character(self):
637
"""See InventoryEntry.kind_character."""
638
return ''
639
640
def _put_in_tar(self, item, tree):
641
"""See InventoryEntry._put_in_tar."""
642
iterm.type = tarfile.SYMTYPE
643
fileobj = None
644
item.size = 0
645
item.mode = 0755
646
item.linkname = self.symlink_target
647
return fileobj
648
649
def _put_on_disk(self, fullpath, tree):
650
"""See InventoryEntry._put_on_disk."""
651
try:
652
os.symlink(self.symlink_target, fullpath)
653
except OSError,e:
654
raise BzrError("Failed to create symlink %r -> %r, error: %s" % (fullpath, self.symlink_target, e))
655
656
def _read_tree_state(self, work_tree):
657
"""See InventoryEntry._read_tree_state."""
658
self.symlink_target = work_tree.get_symlink_target(self.file_id)
659
660
def _unchanged(self, previous_ie):
661
"""See InventoryEntry._unchanged."""
662
compatible = super(InventoryLink, self)._unchanged(previous_ie)
663
if self.symlink_target != previous_ie.symlink_target:
664
compatible = False
665
return compatible
666
667
668
class Inventory(object):
199
669
"""Inventory of versioned files in a tree.
200
670
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.
671
This describes which file_id is present at each point in the tree,
672
and possibly the SHA-1 or other information about the file.
673
Entries can be looked up either by path or by file_id.
207
674
208
675
The inventory represents a typical unix file tree, with
209
676
directories containing files and subdirectories. We never store
213
680
returned quickly.
214
681
215
682
InventoryEntry objects must not be modified after they are
216
inserted.
683
inserted, other than through the Inventory API.
217
684
218
685
>>> inv = Inventory()
219
>>> inv.write_xml(sys.stdout)
220
<inventory>
221
</inventory>
222
>>> inv.add(InventoryEntry('123-123', 'hello.c'))
686
>>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
687
InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
223
688
>>> inv['123-123'].name
224
689
'hello.c'
225
>>> for file_id in inv: print file_id
226
...
227
123-123
228
690
229
691
May be treated as an iterator or set to look up file ids:
230
692
237
699
238
700
>>> [x[0] for x in inv.iter_entries()]
239
701
['hello.c']
240
241
>>> inv.write_xml(sys.stdout)
242
<inventory>
243
<entry file_id="123-123" kind="file" name="hello.c" />
244
</inventory>
245
702
>>> inv = Inventory('TREE_ROOT-12345678-12345678')
703
>>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
704
InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
246
705
"""
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):
706
def __init__(self, root_id=ROOT_ID):
262
707
"""Create or read an inventory.
263
708
264
709
If a working directory is specified, the inventory is read
265
710
from there. If the file is specified, read from that. If not,
266
711
the inventory is created empty.
712
713
The inventory is created with a default root directory, with
714
an id of None.
267
715
"""
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: {}}
716
# We are letting Branch.initialize() create a unique inventory
717
# root id. Rather than generating a random one here.
718
#if root_id is None:
719
# root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
720
self.root = RootEntry(root_id)
721
self._byid = {self.root.file_id: self.root}
722
723
724
def copy(self):
725
other = Inventory(self.root.file_id)
726
# copy recursively so we know directories will be added before
727
# their children. There are more efficient ways than this...
728
for path, entry in self.iter_entries():
729
if entry == self.root:
730
continue
731
other.add(entry.copy())
732
return other
273
733
274
734
275
735
def __iter__(self):
281
741
return len(self._byid)
282
742
283
743
284
def iter_entries(self, parent_id=None):
744
def iter_entries(self, from_dir=None):
285
745
"""Return (path, entry) pairs, in order by name."""
286
kids = self._tree[parent_id].items()
746
if from_dir == None:
747
assert self.root
748
from_dir = self.root
749
elif isinstance(from_dir, basestring):
750
from_dir = self._byid[from_dir]
751
752
kids = from_dir.children.items()
287
753
kids.sort()
288
754
for name, ie in kids:
289
755
yield name, ie
290
756
if ie.kind == 'directory':
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
757
for cn, cie in self.iter_entries(from_dir=ie.file_id):
758
yield os.path.join(name, cn), cie
759
760
761
def entries(self):
762
"""Return list of (path, ie) for all entries except the root.
763
764
This may be faster than iter_entries.
765
"""
766
accum = []
767
def descend(dir_ie, dir_path):
768
kids = dir_ie.children.items()
769
kids.sort()
770
for name, ie in kids:
771
child_path = os.path.join(dir_path, name)
772
accum.append((child_path, ie))
773
if ie.kind == 'directory':
774
descend(ie, child_path)
775
776
descend(self.root, '')
777
return accum
778
779
780
def directories(self):
781
"""Return (path, entry) pairs for all directories, including the root.
782
"""
783
accum = []
784
def descend(parent_ie, parent_path):
785
accum.append((parent_path, parent_ie))
786
787
kids = [(ie.name, ie) for ie in parent_ie.children.itervalues() if ie.kind == 'directory']
788
kids.sort()
789
790
for name, child_ie in kids:
791
child_path = os.path.join(parent_path, name)
792
descend(child_ie, child_path)
793
descend(self.root, '')
794
return accum
303
795
304
796
305
797
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
315
798
def __contains__(self, file_id):
316
799
"""True if this entry contains a file with given id.
317
800
318
801
>>> inv = Inventory()
319
>>> inv.add(InventoryEntry('123', 'foo.c'))
802
>>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
803
InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
320
804
>>> '123' in inv
321
805
True
322
806
>>> '456' in inv
329
813
"""Return the entry for given file_id.
330
814
331
815
>>> inv = Inventory()
332
>>> inv.add(InventoryEntry('123123', 'hello.c'))
816
>>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
817
InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
333
818
>>> inv['123123'].name
334
819
'hello.c'
335
820
"""
336
return self._byid[file_id]
821
try:
822
return self._byid[file_id]
823
except KeyError:
824
if file_id == None:
825
raise BzrError("can't look up file_id None")
826
else:
827
raise BzrError("file_id {%s} not in inventory" % file_id)
828
829
830
def get_file_kind(self, file_id):
831
return self._byid[file_id].kind
832
833
def get_child(self, parent_id, filename):
834
return self[parent_id].children.get(filename)
337
835
338
836
339
837
def add(self, entry):
340
838
"""Add entry to inventory.
341
839
342
840
To add a file to a branch ready to be committed, use Branch.add,
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))
841
which calls this.
842
843
Returns the new entry object.
844
"""
845
if entry.file_id in self._byid:
846
raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
847
848
if entry.parent_id == ROOT_ID or entry.parent_id is None:
849
entry.parent_id = self.root.file_id
850
851
try:
852
parent = self._byid[entry.parent_id]
853
except KeyError:
854
raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
855
856
if parent.children.has_key(entry.name):
857
raise BzrError("%s is already versioned" %
858
appendpath(self.id2path(parent.file_id), entry.name))
355
859
356
860
self._byid[entry.file_id] = entry
357
self._tree[entry.parent_id][entry.name] = entry
358
359
if entry.kind == 'directory':
360
self._tree[entry.file_id] = {}
861
parent.children[entry.name] = entry
862
return entry
863
864
865
def add_path(self, relpath, kind, file_id=None):
866
"""Add entry from a path.
867
868
The immediate parent must already be versioned.
869
870
Returns the new entry object."""
871
from bzrlib.branch import gen_file_id
872
873
parts = bzrlib.osutils.splitpath(relpath)
874
if len(parts) == 0:
875
raise BzrError("cannot re-add root of inventory")
876
877
if file_id == None:
878
file_id = gen_file_id(relpath)
879
880
parent_path = parts[:-1]
881
parent_id = self.path2id(parent_path)
882
if parent_id == None:
883
raise NotVersionedError(parent_path)
884
885
if kind == 'directory':
886
ie = InventoryDirectory(file_id, parts[-1], parent_id)
887
elif kind == 'file':
888
ie = InventoryFile(file_id, parts[-1], parent_id)
889
elif kind == 'symlink':
890
ie = InventoryLink(file_id, parts[-1], parent_id)
891
else:
892
raise BzrError("unknown kind %r" % kind)
893
return self.add(ie)
361
894
362
895
363
896
def __delitem__(self, file_id):
364
897
"""Remove entry by id.
365
898
366
899
>>> inv = Inventory()
367
>>> inv.add(InventoryEntry('123', 'foo.c'))
900
>>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
901
InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
368
902
>>> '123' in inv
369
903
True
370
904
>>> del inv['123']
373
907
"""
374
908
ie = self[file_id]
375
909
376
assert self._tree[ie.parent_id][ie.name] == ie
910
assert self[ie.parent_id].children[ie.name] == ie
377
911
378
912
# TODO: Test deleting all children; maybe hoist to a separate
379
913
# deltree method?
380
914
if ie.kind == 'directory':
381
for cie in self._tree[file_id].values():
915
for cie in ie.children.values():
382
916
del self[cie.file_id]
383
del self._tree[file_id]
917
del ie.children
384
918
385
919
del self._byid[file_id]
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):
920
del self[ie.parent_id].children[ie.name]
921
922
923
def __eq__(self, other):
422
924
"""Compare two sets by comparing their contents.
423
925
424
926
>>> i1 = Inventory()
425
927
>>> i2 = Inventory()
426
928
>>> i1 == i2
427
929
True
428
>>> i1.add(InventoryEntry('123', 'foo'))
930
>>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
931
InventoryFile('123', 'foo', parent_id='TREE_ROOT')
429
932
>>> i1 == i2
430
933
False
431
>>> i2.add(InventoryEntry('123', 'foo'))
934
>>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
935
InventoryFile('123', 'foo', parent_id='TREE_ROOT')
432
936
>>> i1 == i2
433
937
True
434
938
"""
435
if self is other:
436
return 0
437
438
939
if not isinstance(other, Inventory):
439
940
return NotImplemented
440
941
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."""
942
if len(self._byid) != len(other._byid):
943
# shortcut: obviously not the same
944
return False
945
946
return self._byid == other._byid
947
948
949
def __ne__(self, other):
950
return not self.__eq__(other)
951
952
953
def __hash__(self):
954
raise ValueError('not hashable')
955
956
957
def get_idpath(self, file_id):
958
"""Return a list of file_ids for the path to an entry.
959
960
The list contains one element for each directory followed by
961
the id of the file itself. So the length of the returned list
962
is equal to the depth of the file in the tree, counting the
963
root directory as depth 1.
964
"""
453
965
p = []
454
966
while file_id != None:
455
ie = self[file_id]
456
p = [ie.name] + p
967
try:
968
ie = self._byid[file_id]
969
except KeyError:
970
raise BzrError("file_id {%s} not found in inventory" % file_id)
971
p.insert(0, ie.file_id)
457
972
file_id = ie.parent_id
458
return joinpath(p)
973
return p
974
975
976
def id2path(self, file_id):
977
"""Return as a list the path to file_id.
978
979
>>> i = Inventory()
980
>>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))
981
>>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))
982
>>> print i.id2path('foo-id').replace(os.sep, '/')
983
src/foo.c
984
"""
985
# get all names, skipping root
986
p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
987
return os.sep.join(p)
459
988
460
989
461
990
467
996
468
997
This returns the entry of the last component in the path,
469
998
which may be either a file or a directory.
999
1000
Returns None iff the path is not found.
470
1001
"""
471
assert isinstance(name, types.StringTypes)
472
473
parent_id = None
474
for f in splitpath(name):
1002
if isinstance(name, types.StringTypes):
1003
name = splitpath(name)
1004
1005
mutter("lookup path %r" % name)
1006
1007
parent = self.root
1008
for f in name:
475
1009
try:
476
cie = self._tree[parent_id][f]
1010
cie = parent.children[f]
477
1011
assert cie.name == f
478
parent_id = cie.file_id
1012
assert cie.parent_id == parent.file_id
1013
parent = cie
479
1014
except KeyError:
480
1015
# or raise an error?
481
1016
return None
482
1017
483
return parent_id
484
485
486
def get_child(self, parent_id, child_name):
487
return self._tree[parent_id].get(child_name)
1018
return parent.file_id
488
1019
489
1020
490
1021
def has_filename(self, names):
492
1023
493
1024
494
1025
def has_id(self, file_id):
495
assert isinstance(file_id, str)
496
1026
return self._byid.has_key(file_id)
497
1027
498
1028
499
500
if __name__ == '__main__':
501
import doctest, inventory
502
doctest.testmod(inventory)
1029
def rename(self, file_id, new_parent_id, new_name):
1030
"""Move a file within the inventory.
1031
1032
This can change either the name, or the parent, or both.
1033
1034
This does not move the working file."""
1035
if not is_valid_name(new_name):
1036
raise BzrError("not an acceptable filename: %r" % new_name)
1037
1038
new_parent = self._byid[new_parent_id]
1039
if new_name in new_parent.children:
1040
raise BzrError("%r already exists in %r" % (new_name, self.id2path(new_parent_id)))
1041
1042
new_parent_idpath = self.get_idpath(new_parent_id)
1043
if file_id in new_parent_idpath:
1044
raise BzrError("cannot move directory %r into a subdirectory of itself, %r"
1045
% (self.id2path(file_id), self.id2path(new_parent_id)))
1046
1047
file_ie = self._byid[file_id]
1048
old_parent = self._byid[file_ie.parent_id]
1049
1050
# TODO: Don't leave things messed up if this fails
1051
1052
del old_parent.children[file_ie.name]
1053
new_parent.children[new_name] = file_ie
1054
1055
file_ie.name = new_name
1056
file_ie.parent_id = new_parent_id
1057
1058
1059
1060
1061
_NAME_RE = None
1062
1063
def is_valid_name(name):
1064
global _NAME_RE
1065
if _NAME_RE == None:
1066
_NAME_RE = re.compile(r'^[^/\\]+$')
1067
1068
return bool(_NAME_RE.match(name))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1