« back to all changes in this revision
Viewing changes to bzrlib/inventory.py
- browse files at revision 1442.1.20
- compare with another revision
- download diff
- download tarball
- view history from revision 1442.1.20
- Committer: Robert Collins
- Date: 2005-10-15 00:32:03 UTC
- mto: This revision was merged to the branch mainline in revision 1456.
- Revision ID: robertc@lifelesslap.robertcollins.net-20051015003203-38a52da69f847663
add some documentation on options
- files added:
- NEWS.developers
- bzrlib/store
- bzrlib/transport
- files removed:
- bzrlib/meta_store.py
- files renamed:
- tools/testweave.py => bzrlib/selftest/test_weave.py
- bzrlib/store.py => bzrlib/store/__init__.py
- bzrlib/weavestore.py => bzrlib/store/weave.py
- tools/history2weaves.py => bzrlib/upgrade.py
- files modified:
- .bzrignore
- bzr *
added
removed
bzrlib/inventory.py
1
1
# (C) 2005 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
12
12
#
13
13
# You should have received a copy of the GNU General Public License
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
19
19
# But those depend on its position within a particular inventory, and
20
20
# it would be nice not to need to hold the backpointer here.
21
21
22
# TODO: Perhaps split InventoryEntry into subclasses for files,
23
# directories, etc etc.
24
25
26
22
# This should really be an id randomly assigned when the tree is
27
23
# created, but it's not for now.
28
24
ROOT_ID = "TREE_ROOT"
29
25
30
26
31
import sys, os.path, types, re
27
import os.path
28
import re
29
import sys
30
import tarfile
31
import types
32
32
33
33
import bzrlib
34
34
from bzrlib.errors import BzrError, BzrCheckError
35
35
36
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
36
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
37
appendpath, sha_strings)
37
38
from bzrlib.trace import mutter
38
39
from bzrlib.errors import NotVersionedError
39
40
40
41
41
42
class InventoryEntry(object):
42
43
"""Description of a versioned file.
49
50
name
50
51
(within the parent directory)
51
52
52
kind
53
'directory' or 'file'
54
55
53
parent_id
56
54
file_id of the parent directory, or ROOT_ID
57
55
58
entry_version
59
the revision_id in which the name or parent of this file was
60
last changed
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.
61
63
62
64
text_sha1
63
65
sha-1 of the text of the file
65
67
text_size
66
68
size in bytes of the text of the file
67
69
68
text_version
69
the revision_id in which the text of this file was introduced
70
71
70
(reading a version 4 tree created a text_id field.)
72
71
73
72
>>> i = Inventory()
74
73
>>> i.path2id('')
75
74
'TREE_ROOT'
76
>>> i.add(InventoryEntry('123', 'src', 'directory', ROOT_ID))
77
InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT')
78
>>> i.add(InventoryEntry('2323', 'hello.c', 'file', parent_id='123'))
79
InventoryEntry('2323', 'hello.c', kind='file', parent_id='123')
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')
80
79
>>> for j in i.iter_entries():
81
80
... print j
82
81
...
83
('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
84
('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
85
>>> i.add(InventoryEntry('2323', 'bye.c', 'file', '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'))
86
85
Traceback (most recent call last):
87
86
...
88
87
BzrError: inventory already contains entry with id {2323}
89
>>> i.add(InventoryEntry('2324', 'bye.c', 'file', '123'))
90
InventoryEntry('2324', 'bye.c', kind='file', parent_id='123')
91
>>> i.add(InventoryEntry('2325', 'wibble', 'directory', '123'))
92
InventoryEntry('2325', 'wibble', kind='directory', parent_id='123')
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')
93
92
>>> i.path2id('src/wibble')
94
93
'2325'
95
94
>>> '2325' in i
96
95
True
97
>>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
98
InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
96
>>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
97
InventoryFile('2326', 'wibble.c', parent_id='2325')
99
98
>>> i['2326']
100
InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
101
>>> for j in i.iter_entries():
102
... print j[0]
103
... 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)
104
103
...
105
104
src
106
105
src/bye.c
107
106
src/hello.c
108
107
src/wibble
109
108
src/wibble/wibble.c
110
>>> i.id2path('2326')
109
>>> i.id2path('2326').replace('\\\\', '/')
111
110
'src/wibble/wibble.c'
112
111
"""
113
112
114
113
__slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
115
'text_id', 'parent_id', 'children',
116
'text_version', 'entry_version', ]
117
118
119
def __init__(self, file_id, name, kind, parent_id, text_id=None):
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):
120
219
"""Create an InventoryEntry
121
220
122
221
The filename must be a single component, relative to the
123
222
parent directory; it cannot be a whole path or relative name.
124
223
125
>>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
224
>>> e = InventoryFile('123', 'hello.c', ROOT_ID)
126
225
>>> e.name
127
226
'hello.c'
128
227
>>> e.file_id
129
228
'123'
130
>>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
229
>>> e = InventoryFile('123', 'src/hello.c', ROOT_ID)
131
230
Traceback (most recent call last):
132
231
BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
133
232
"""
135
234
if '/' in name or '\\' in name:
136
235
raise BzrCheckError('InventoryEntry name %r is invalid' % name)
137
236
138
self.text_version = None
139
self.entry_version = None
237
self.executable = False
238
self.revision = None
140
239
self.text_sha1 = None
141
240
self.text_size = None
142
241
self.file_id = file_id
143
242
self.name = name
144
self.kind = kind
145
243
self.text_id = text_id
146
244
self.parent_id = parent_id
147
if kind == 'directory':
148
self.children = {}
149
elif kind == 'file':
150
pass
151
else:
152
raise BzrError("unhandled entry kind %r" % kind)
153
154
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))
155
273
156
274
def sorted_children(self):
157
275
l = self.children.items()
158
276
l.sort()
159
277
return l
160
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))
299
161
300
162
301
def copy(self):
163
other = InventoryEntry(self.file_id, self.name, self.kind,
164
self.parent_id)
165
other.text_id = self.text_id
166
other.text_sha1 = self.text_sha1
167
other.text_size = self.text_size
168
other.text_version = self.text_version
169
# note that children are *not* copied; they're pulled across when
170
# others are added
171
return other
302
"""Clone this inventory entry."""
303
raise NotImplementedError
172
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'
173
312
174
313
def __repr__(self):
175
return ("%s(%r, %r, kind=%r, parent_id=%r)"
314
return ("%s(%r, %r, parent_id=%r)"
176
315
% (self.__class__.__name__,
177
316
self.file_id,
178
317
self.name,
179
self.kind,
180
318
self.parent_id))
181
319
182
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
183
358
def __eq__(self, other):
184
359
if not isinstance(other, InventoryEntry):
185
360
return NotImplemented
186
361
187
return (self.file_id == other.file_id) \
188
and (self.name == other.name) \
189
and (self.text_sha1 == other.text_sha1) \
190
and (self.text_size == other.text_size) \
191
and (self.text_id == other.text_id) \
192
and (self.parent_id == other.parent_id) \
193
and (self.kind == other.kind) \
194
and (self.text_version == other.text_version) \
195
and (self.entry_version == other.entry_version)
196
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
)
197
373
198
374
def __ne__(self, other):
199
375
return not (self == other)
201
377
def __hash__(self):
202
378
raise ValueError('not hashable')
203
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
204
404
205
405
206
406
class RootEntry(InventoryEntry):
407
408
def _check(self, checker, rev_id, tree):
409
"""See InventoryEntry._check"""
410
207
411
def __init__(self, file_id):
208
412
self.file_id = file_id
209
413
self.children = {}
219
423
and (self.children == other.children)
220
424
221
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
222
671
223
672
class Inventory(object):
224
673
"""Inventory of versioned files in a tree.
238
687
inserted, other than through the Inventory API.
239
688
240
689
>>> inv = Inventory()
241
>>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
242
InventoryEntry('123-123', 'hello.c', kind='file', parent_id='TREE_ROOT')
690
>>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
691
InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
243
692
>>> inv['123-123'].name
244
693
'hello.c'
245
694
255
704
>>> [x[0] for x in inv.iter_entries()]
256
705
['hello.c']
257
706
>>> inv = Inventory('TREE_ROOT-12345678-12345678')
258
>>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
259
InventoryEntry('123-123', 'hello.c', kind='file', parent_id='TREE_ROOT-12345678-12345678')
707
>>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
708
InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
260
709
"""
261
710
def __init__(self, root_id=ROOT_ID):
262
711
"""Create or read an inventory.
268
717
The inventory is created with a default root directory, with
269
718
an id of None.
270
719
"""
271
# We are letting Branch(init=True) create a unique inventory
720
# We are letting Branch.initialize() create a unique inventory
272
721
# root id. Rather than generating a random one here.
273
722
#if root_id is None:
274
723
# root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
354
803
"""True if this entry contains a file with given id.
355
804
356
805
>>> inv = Inventory()
357
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
358
InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
806
>>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
807
InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
359
808
>>> '123' in inv
360
809
True
361
810
>>> '456' in inv
368
817
"""Return the entry for given file_id.
369
818
370
819
>>> inv = Inventory()
371
>>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
372
InventoryEntry('123123', 'hello.c', kind='file', parent_id='TREE_ROOT')
820
>>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
821
InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
373
822
>>> inv['123123'].name
374
823
'hello.c'
375
824
"""
437
886
if parent_id == None:
438
887
raise NotVersionedError(parent_path)
439
888
440
ie = InventoryEntry(file_id, parts[-1],
441
kind=kind, parent_id=parent_id)
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)
442
897
return self.add(ie)
443
898
444
899
446
901
"""Remove entry by id.
447
902
448
903
>>> inv = Inventory()
449
>>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
450
InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
904
>>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
905
InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
451
906
>>> '123' in inv
452
907
True
453
908
>>> del inv['123']
476
931
>>> i2 = Inventory()
477
932
>>> i1 == i2
478
933
True
479
>>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
480
InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
934
>>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
935
InventoryFile('123', 'foo', parent_id='TREE_ROOT')
481
936
>>> i1 == i2
482
937
False
483
>>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
484
InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
938
>>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
939
InventoryFile('123', 'foo', parent_id='TREE_ROOT')
485
940
>>> i1 == i2
486
941
True
487
942
"""
496
951
497
952
498
953
def __ne__(self, other):
499
return not (self == other)
954
return not self.__eq__(other)
500
955
501
956
502
957
def __hash__(self):
523
978
524
979
525
980
def id2path(self, file_id):
526
"""Return as a list the path to file_id."""
527
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
"""
528
989
# get all names, skipping root
529
990
p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
530
991
return os.sep.join(p)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1