← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

Merge in format-5 work - release bzr 0.1rc1.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
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
 
18
22
# This should really be an id randomly assigned when the tree is
19
23
# created, but it's not for now.
20
24
ROOT_ID = "TREE_ROOT"
21
25
 
22
26
 
23
 
import sys, os.path, types, re
 
27
import os.path
 
28
import re
 
29
import sys
 
30
import tarfile
 
31
import types
24
32
 
25
33
import bzrlib
26
34
from bzrlib.errors import BzrError, BzrCheckError
27
35
 
28
 
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
 
36
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
 
37
                            appendpath, sha_strings)
29
38
from bzrlib.trace import mutter
30
39
from bzrlib.errors import NotVersionedError
31
 
        
 
40
 
32
41
 
33
42
class InventoryEntry(object):
34
43
    """Description of a versioned file.
36
45
    An InventoryEntry has the following fields, which are also
37
46
    present in the XML inventory-entry element:
38
47
 
39
 
    * *file_id*
40
 
    * *name*: (only the basename within the directory, must not
41
 
      contain slashes)
42
 
    * *kind*: "directory" or "file"
43
 
    * *directory_id*: (if absent/null means the branch root directory)
44
 
    * *text_sha1*: only for files
45
 
    * *text_size*: in bytes, only for files 
46
 
    * *text_id*: identifier for the text version, only for files
47
 
 
48
 
    InventoryEntries can also exist inside a WorkingTree
49
 
    inventory, in which case they are not yet bound to a
50
 
    particular revision of the file.  In that case the text_sha1,
51
 
    text_size and text_id are absent.
52
 
 
 
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.)
53
71
 
54
72
    >>> i = Inventory()
55
73
    >>> i.path2id('')
56
74
    'TREE_ROOT'
57
 
    >>> i.add(InventoryEntry('123', 'src', 'directory', ROOT_ID))
58
 
    InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT')
59
 
    >>> i.add(InventoryEntry('2323', 'hello.c', 'file', parent_id='123'))
60
 
    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')
61
79
    >>> for j in i.iter_entries():
62
80
    ...   print j
63
81
    ... 
64
 
    ('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
65
 
    ('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
66
 
    >>> 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'))
67
85
    Traceback (most recent call last):
68
86
    ...
69
87
    BzrError: inventory already contains entry with id {2323}
70
 
    >>> i.add(InventoryEntry('2324', 'bye.c', 'file', '123'))
71
 
    InventoryEntry('2324', 'bye.c', kind='file', parent_id='123')
72
 
    >>> i.add(InventoryEntry('2325', 'wibble', 'directory', '123'))
73
 
    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')
74
92
    >>> i.path2id('src/wibble')
75
93
    '2325'
76
94
    >>> '2325' in i
77
95
    True
78
 
    >>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
79
 
    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')
80
98
    >>> i['2326']
81
 
    InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
82
 
    >>> for j in i.iter_entries():
83
 
    ...     print j[0]
84
 
    ...     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)
85
103
    ... 
86
104
    src
87
105
    src/bye.c
88
106
    src/hello.c
89
107
    src/wibble
90
108
    src/wibble/wibble.c
91
 
    >>> i.id2path('2326')
 
109
    >>> i.id2path('2326').replace('\\\\', '/')
92
110
    'src/wibble/wibble.c'
93
 
 
94
 
    TODO: Maybe also keep the full path of the entry, and the children?
95
 
           But those depend on its position within a particular inventory, and
96
 
           it would be nice not to need to hold the backpointer here.
97
111
    """
98
 
 
99
 
    # TODO: split InventoryEntry into subclasses for files,
100
 
    # directories, etc etc.
101
 
 
 
112
    
102
113
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
103
 
                 'text_id', 'parent_id', 'children',
104
 
                 'text_version', 'entry_version', ]
105
 
 
106
 
 
107
 
    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):
 
118
        weave_store.add_text(self.file_id, self.revision, new_lines, parents)
 
119
 
 
120
    def detect_changes(self, old_entry):
 
121
        """Return a (text_modified, meta_modified) from this to old_entry.
 
122
        
 
123
        _read_tree_state must have been called on self and old_entry prior to 
 
124
        calling detect_changes.
 
125
        """
 
126
        return False, False
 
127
 
 
128
    def diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
129
             output_to, reverse=False):
 
130
        """Perform a diff from this to to_entry.
 
131
 
 
132
        text_diff will be used for textual difference calculation.
 
133
        This is a template method, override _diff in child classes.
 
134
        """
 
135
        self._read_tree_state(tree.id2path(self.file_id), tree)
 
136
        if to_entry:
 
137
            # cannot diff from one kind to another - you must do a removal
 
138
            # and an addif they do not match.
 
139
            assert self.kind == to_entry.kind
 
140
            to_entry._read_tree_state(to_tree.id2path(to_entry.file_id),
 
141
                                      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
                    assert heads[ie.revision] == ie
 
169
                else:
 
170
                    # may want to add it.
 
171
                    # may already be covered:
 
172
                    already_present = 0 != len(
 
173
                        [head for head in heads 
 
174
                         if ie.revision in head_ancestors[head]])
 
175
                    if already_present:
 
176
                        # an ancestor of a known head.
 
177
                        continue
 
178
                    # definately a head:
 
179
                    ancestors = get_ancestors(entry_weave, ie)
 
180
                    # may knock something else out:
 
181
                    check_heads = list(heads.keys())
 
182
                    for head in check_heads:
 
183
                        if head in ancestors:
 
184
                            # this head is not really a head
 
185
                            heads.pop(head)
 
186
                    head_ancestors[ie.revision] = ancestors
 
187
                    heads[ie.revision] = ie
 
188
        return heads
 
189
 
 
190
    def get_tar_item(self, root, dp, now, tree):
 
191
        """Get a tarfile item and a file stream for its content."""
 
192
        item = tarfile.TarInfo(os.path.join(root, dp))
 
193
        # TODO: would be cool to actually set it to the timestamp of the
 
194
        # revision it was last changed
 
195
        item.mtime = now
 
196
        fileobj = self._put_in_tar(item, tree)
 
197
        return item, fileobj
 
198
 
 
199
    def has_text(self):
 
200
        """Return true if the object this entry represents has textual data.
 
201
 
 
202
        Note that textual data includes binary content.
 
203
 
 
204
        Also note that all entries get weave files created for them.
 
205
        This attribute is primarily used when upgrading from old trees that
 
206
        did not have the weave index for all inventory entries.
 
207
        """
 
208
        return False
 
209
 
 
210
    def __init__(self, file_id, name, parent_id, text_id=None):
108
211
        """Create an InventoryEntry
109
212
        
110
213
        The filename must be a single component, relative to the
111
214
        parent directory; it cannot be a whole path or relative name.
112
215
 
113
 
        >>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
 
216
        >>> e = InventoryFile('123', 'hello.c', ROOT_ID)
114
217
        >>> e.name
115
218
        'hello.c'
116
219
        >>> e.file_id
117
220
        '123'
118
 
        >>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
 
221
        >>> e = InventoryFile('123', 'src/hello.c', ROOT_ID)
119
222
        Traceback (most recent call last):
120
223
        BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
121
224
        """
123
226
        if '/' in name or '\\' in name:
124
227
            raise BzrCheckError('InventoryEntry name %r is invalid' % name)
125
228
        
126
 
        self.text_version = None
127
 
        self.entry_version = None
 
229
        self.executable = False
 
230
        self.revision = None
128
231
        self.text_sha1 = None
129
232
        self.text_size = None
130
233
        self.file_id = file_id
131
234
        self.name = name
132
 
        self.kind = kind
133
235
        self.text_id = text_id
134
236
        self.parent_id = parent_id
135
 
        if kind == 'directory':
136
 
            self.children = {}
137
 
        elif kind == 'file':
138
 
            pass
139
 
        else:
140
 
            raise BzrError("unhandled entry kind %r" % kind)
141
 
 
142
 
 
 
237
        self.symlink_target = None
 
238
 
 
239
    def kind_character(self):
 
240
        """Return a short kind indicator useful for appending to names."""
 
241
        raise BzrError('unknown kind %r' % self.kind)
 
242
 
 
243
    known_kinds = ('file', 'directory', 'symlink', 'root_directory')
 
244
 
 
245
    def _put_in_tar(self, item, tree):
 
246
        """populate item for stashing in a tar, and return the content stream.
 
247
 
 
248
        If no content is available, return None.
 
249
        """
 
250
        raise BzrError("don't know how to export {%s} of kind %r" %
 
251
                       (self.file_id, self.kind))
 
252
 
 
253
    def put_on_disk(self, dest, dp, tree):
 
254
        """Create a representation of self on disk in the prefix dest.
 
255
        
 
256
        This is a template method - implement _put_on_disk in subclasses.
 
257
        """
 
258
        fullpath = appendpath(dest, dp)
 
259
        self._put_on_disk(fullpath, tree)
 
260
        mutter("  export {%s} kind %s to %s" % (self.file_id, self.kind, fullpath))
 
261
 
 
262
    def _put_on_disk(self, fullpath, tree):
 
263
        """Put this entry onto disk at fullpath, from tree tree."""
 
264
        raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
143
265
 
144
266
    def sorted_children(self):
145
267
        l = self.children.items()
146
268
        l.sort()
147
269
        return l
148
270
 
 
271
    @staticmethod
 
272
    def versionable_kind(kind):
 
273
        return kind in ('file', 'directory', 'symlink')
 
274
 
 
275
    def check(self, checker, rev_id, inv, tree):
 
276
        """Check this inventory entry is intact.
 
277
 
 
278
        This is a template method, override _check for kind specific
 
279
        tests.
 
280
        """
 
281
        if self.parent_id != None:
 
282
            if not inv.has_id(self.parent_id):
 
283
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
 
284
                        % (self.parent_id, rev_id))
 
285
        self._check(checker, rev_id, tree)
 
286
 
 
287
    def _check(self, checker, rev_id, tree):
 
288
        """Check this inventory entry for kind specific errors."""
 
289
        raise BzrCheckError('unknown entry kind %r in revision {%s}' % 
 
290
                            (self.kind, rev_id))
 
291
 
149
292
 
150
293
    def copy(self):
151
 
        other = InventoryEntry(self.file_id, self.name, self.kind,
152
 
                               self.parent_id, text_id=self.text_id)
153
 
        other.text_sha1 = self.text_sha1
154
 
        other.text_size = self.text_size
155
 
        # note that children are *not* copied; they're pulled across when
156
 
        # others are added
157
 
        return other
 
294
        """Clone this inventory entry."""
 
295
        raise NotImplementedError
158
296
 
 
297
    def _get_snapshot_change(self, previous_entries):
 
298
        if len(previous_entries) > 1:
 
299
            return 'merged'
 
300
        elif len(previous_entries) == 0:
 
301
            return 'added'
 
302
        else:
 
303
            return 'modified/renamed/reparented'
159
304
 
160
305
    def __repr__(self):
161
 
        return ("%s(%r, %r, kind=%r, parent_id=%r)"
 
306
        return ("%s(%r, %r, parent_id=%r)"
162
307
                % (self.__class__.__name__,
163
308
                   self.file_id,
164
309
                   self.name,
165
 
                   self.kind,
166
310
                   self.parent_id))
167
311
 
168
 
    
 
312
    def snapshot(self, revision, path, previous_entries,
 
313
                 work_tree, weave_store):
 
314
        """Make a snapshot of this entry which may or may not have changed.
 
315
        
 
316
        This means that all its fields are populated, that it has its
 
317
        text stored in the text store or weave.
 
318
        """
 
319
        mutter('new parents of %s are %r', path, previous_entries)
 
320
        self._read_tree_state(path, work_tree)
 
321
        if len(previous_entries) == 1:
 
322
            # cannot be unchanged unless there is only one parent file rev.
 
323
            parent_ie = previous_entries.values()[0]
 
324
            if self._unchanged(parent_ie):
 
325
                mutter("found unchanged entry")
 
326
                self.revision = parent_ie.revision
 
327
                return "unchanged"
 
328
        return self.snapshot_revision(revision, previous_entries, 
 
329
                                      work_tree, weave_store)
 
330
 
 
331
    def snapshot_revision(self, revision, previous_entries, work_tree,
 
332
                          weave_store):
 
333
        """Record this revision unconditionally."""
 
334
        mutter('new revision for {%s}', self.file_id)
 
335
        self.revision = revision
 
336
        change = self._get_snapshot_change(previous_entries)
 
337
        self._snapshot_text(previous_entries, work_tree, weave_store)
 
338
        return change
 
339
 
 
340
    def _snapshot_text(self, file_parents, work_tree, weave_store): 
 
341
        """Record the 'text' of this entry, whatever form that takes.
 
342
        
 
343
        This default implementation simply adds an empty text.
 
344
        """
 
345
        mutter('storing file {%s} in revision {%s}',
 
346
               self.file_id, self.revision)
 
347
        self._add_text_to_weave([], file_parents, weave_store)
 
348
 
169
349
    def __eq__(self, other):
170
350
        if not isinstance(other, InventoryEntry):
171
351
            return NotImplemented
172
352
 
173
 
        return (self.file_id == other.file_id) \
174
 
               and (self.name == other.name) \
175
 
               and (self.text_sha1 == other.text_sha1) \
176
 
               and (self.text_size == other.text_size) \
177
 
               and (self.text_id == other.text_id) \
178
 
               and (self.parent_id == other.parent_id) \
179
 
               and (self.kind == other.kind) \
180
 
               and (self.text_version == other.text_version) \
181
 
               and (self.entry_version == other.entry_version)
182
 
 
 
353
        return ((self.file_id == other.file_id)
 
354
                and (self.name == other.name)
 
355
                and (other.symlink_target == self.symlink_target)
 
356
                and (self.text_sha1 == other.text_sha1)
 
357
                and (self.text_size == other.text_size)
 
358
                and (self.text_id == other.text_id)
 
359
                and (self.parent_id == other.parent_id)
 
360
                and (self.kind == other.kind)
 
361
                and (self.revision == other.revision)
 
362
                and (self.executable == other.executable)
 
363
                )
183
364
 
184
365
    def __ne__(self, other):
185
366
        return not (self == other)
187
368
    def __hash__(self):
188
369
        raise ValueError('not hashable')
189
370
 
 
371
    def _unchanged(self, previous_ie):
 
372
        """Has this entry changed relative to previous_ie.
 
373
 
 
374
        This method should be overriden in child classes.
 
375
        """
 
376
        compatible = True
 
377
        # different inv parent
 
378
        if previous_ie.parent_id != self.parent_id:
 
379
            compatible = False
 
380
        # renamed
 
381
        elif previous_ie.name != self.name:
 
382
            compatible = False
 
383
        return compatible
 
384
 
 
385
    def _read_tree_state(self, path, work_tree):
 
386
        """Populate fields in the inventory entry from the given tree.
 
387
        
 
388
        Note that this should be modified to be a noop on virtual trees
 
389
        as all entries created there are prepopulated.
 
390
        """
190
391
 
191
392
 
192
393
class RootEntry(InventoryEntry):
 
394
 
 
395
    def _check(self, checker, rev_id, tree):
 
396
        """See InventoryEntry._check"""
 
397
 
193
398
    def __init__(self, file_id):
194
399
        self.file_id = file_id
195
400
        self.children = {}
205
410
               and (self.children == other.children)
206
411
 
207
412
 
 
413
class InventoryDirectory(InventoryEntry):
 
414
    """A directory in an inventory."""
 
415
 
 
416
    def _check(self, checker, rev_id, tree):
 
417
        """See InventoryEntry._check"""
 
418
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
 
419
            raise BzrCheckError('directory {%s} has text in revision {%s}'
 
420
                                % (self.file_id, rev_id))
 
421
 
 
422
    def copy(self):
 
423
        other = InventoryDirectory(self.file_id, self.name, self.parent_id)
 
424
        other.revision = self.revision
 
425
        # note that children are *not* copied; they're pulled across when
 
426
        # others are added
 
427
        return other
 
428
 
 
429
    def __init__(self, file_id, name, parent_id):
 
430
        super(InventoryDirectory, self).__init__(file_id, name, parent_id)
 
431
        self.children = {}
 
432
        self.kind = 'directory'
 
433
 
 
434
    def kind_character(self):
 
435
        """See InventoryEntry.kind_character."""
 
436
        return '/'
 
437
 
 
438
    def _put_in_tar(self, item, tree):
 
439
        """See InventoryEntry._put_in_tar."""
 
440
        item.type = tarfile.DIRTYPE
 
441
        fileobj = None
 
442
        item.name += '/'
 
443
        item.size = 0
 
444
        item.mode = 0755
 
445
        return fileobj
 
446
 
 
447
    def _put_on_disk(self, fullpath, tree):
 
448
        """See InventoryEntry._put_on_disk."""
 
449
        os.mkdir(fullpath)
 
450
 
 
451
 
 
452
class InventoryFile(InventoryEntry):
 
453
    """A file in an inventory."""
 
454
 
 
455
    def _check(self, checker, rev_id, tree):
 
456
        """See InventoryEntry._check"""
 
457
        revision = self.revision
 
458
        t = (self.file_id, revision)
 
459
        if t in checker.checked_texts:
 
460
            prev_sha = checker.checked_texts[t] 
 
461
            if prev_sha != self.text_sha1:
 
462
                raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
 
463
                                    (self.file_id, rev_id))
 
464
            else:
 
465
                checker.repeated_text_cnt += 1
 
466
                return
 
467
        mutter('check version {%s} of {%s}', rev_id, self.file_id)
 
468
        file_lines = tree.get_file_lines(self.file_id)
 
469
        checker.checked_text_cnt += 1 
 
470
        if self.text_size != sum(map(len, file_lines)):
 
471
            raise BzrCheckError('text {%s} wrong size' % self.text_id)
 
472
        if self.text_sha1 != sha_strings(file_lines):
 
473
            raise BzrCheckError('text {%s} wrong sha1' % self.text_id)
 
474
        checker.checked_texts[t] = self.text_sha1
 
475
 
 
476
    def copy(self):
 
477
        other = InventoryFile(self.file_id, self.name, self.parent_id)
 
478
        other.executable = self.executable
 
479
        other.text_id = self.text_id
 
480
        other.text_sha1 = self.text_sha1
 
481
        other.text_size = self.text_size
 
482
        other.revision = self.revision
 
483
        return other
 
484
 
 
485
    def detect_changes(self, old_entry):
 
486
        """See InventoryEntry.detect_changes."""
 
487
        assert self.text_sha1 != None
 
488
        assert old_entry.text_sha1 != None
 
489
        text_modified = (self.text_sha1 != old_entry.text_sha1)
 
490
        meta_modified = (self.executable != old_entry.executable)
 
491
        return text_modified, meta_modified
 
492
 
 
493
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
494
             output_to, reverse=False):
 
495
        """See InventoryEntry._diff."""
 
496
        from_text = tree.get_file(self.file_id).readlines()
 
497
        if to_entry:
 
498
            to_text = to_tree.get_file(to_entry.file_id).readlines()
 
499
        else:
 
500
            to_text = []
 
501
        if not reverse:
 
502
            text_diff(from_label, from_text,
 
503
                      to_label, to_text, output_to)
 
504
        else:
 
505
            text_diff(to_label, to_text,
 
506
                      from_label, from_text, output_to)
 
507
 
 
508
    def has_text(self):
 
509
        """See InventoryEntry.has_text."""
 
510
        return True
 
511
 
 
512
    def __init__(self, file_id, name, parent_id):
 
513
        super(InventoryFile, self).__init__(file_id, name, parent_id)
 
514
        self.kind = 'file'
 
515
 
 
516
    def kind_character(self):
 
517
        """See InventoryEntry.kind_character."""
 
518
        return ''
 
519
 
 
520
    def _put_in_tar(self, item, tree):
 
521
        """See InventoryEntry._put_in_tar."""
 
522
        item.type = tarfile.REGTYPE
 
523
        fileobj = tree.get_file(self.file_id)
 
524
        item.size = self.text_size
 
525
        if tree.is_executable(self.file_id):
 
526
            item.mode = 0755
 
527
        else:
 
528
            item.mode = 0644
 
529
        return fileobj
 
530
 
 
531
    def _put_on_disk(self, fullpath, tree):
 
532
        """See InventoryEntry._put_on_disk."""
 
533
        pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
 
534
        if tree.is_executable(self.file_id):
 
535
            os.chmod(fullpath, 0755)
 
536
 
 
537
    def _read_tree_state(self, path, work_tree):
 
538
        """See InventoryEntry._read_tree_state."""
 
539
        self.text_sha1 = work_tree.get_file_sha1(self.file_id)
 
540
        self.executable = work_tree.is_executable(self.file_id)
 
541
 
 
542
    def _snapshot_text(self, file_parents, work_tree, weave_store): 
 
543
        """See InventoryEntry._snapshot_text."""
 
544
        mutter('storing file {%s} in revision {%s}',
 
545
               self.file_id, self.revision)
 
546
        # special case to avoid diffing on renames or 
 
547
        # reparenting
 
548
        if (len(file_parents) == 1
 
549
            and self.text_sha1 == file_parents.values()[0].text_sha1
 
550
            and self.text_size == file_parents.values()[0].text_size):
 
551
            previous_ie = file_parents.values()[0]
 
552
            weave_store.add_identical_text(
 
553
                self.file_id, previous_ie.revision, 
 
554
                self.revision, file_parents)
 
555
        else:
 
556
            new_lines = work_tree.get_file(self.file_id).readlines()
 
557
            self._add_text_to_weave(new_lines, file_parents, weave_store)
 
558
            self.text_sha1 = sha_strings(new_lines)
 
559
            self.text_size = sum(map(len, new_lines))
 
560
 
 
561
 
 
562
    def _unchanged(self, previous_ie):
 
563
        """See InventoryEntry._unchanged."""
 
564
        compatible = super(InventoryFile, self)._unchanged(previous_ie)
 
565
        if self.text_sha1 != previous_ie.text_sha1:
 
566
            compatible = False
 
567
        else:
 
568
            # FIXME: 20050930 probe for the text size when getting sha1
 
569
            # in _read_tree_state
 
570
            self.text_size = previous_ie.text_size
 
571
        return compatible
 
572
 
 
573
 
 
574
class InventoryLink(InventoryEntry):
 
575
    """A file in an inventory."""
 
576
 
 
577
    __slots__ = ['symlink_target']
 
578
 
 
579
    def _check(self, checker, rev_id, tree):
 
580
        """See InventoryEntry._check"""
 
581
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
 
582
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
 
583
                    % (self.file_id, rev_id))
 
584
        if self.symlink_target == None:
 
585
            raise BzrCheckError('symlink {%s} has no target in revision {%s}'
 
586
                    % (self.file_id, rev_id))
 
587
 
 
588
    def copy(self):
 
589
        other = InventoryLink(self.file_id, self.name, self.parent_id)
 
590
        other.symlink_target = self.symlink_target
 
591
        other.revision = self.revision
 
592
        return other
 
593
 
 
594
    def detect_changes(self, old_entry):
 
595
        """See InventoryEntry.detect_changes."""
 
596
        # FIXME: which _modified field should we use ? RBC 20051003
 
597
        text_modified = (self.symlink_target != old_entry.symlink_target)
 
598
        if text_modified:
 
599
            mutter("    symlink target changed")
 
600
        meta_modified = False
 
601
        return text_modified, meta_modified
 
602
 
 
603
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
604
             output_to, reverse=False):
 
605
        """See InventoryEntry._diff."""
 
606
        from_text = self.symlink_target
 
607
        if to_entry is not None:
 
608
            to_text = to_entry.symlink_target
 
609
            if reverse:
 
610
                temp = from_text
 
611
                from_text = to_text
 
612
                to_text = temp
 
613
            print >>output_to, '=== target changed %r => %r' % (from_text, to_text)
 
614
        else:
 
615
            if not reverse:
 
616
                print >>output_to, '=== target was %r' % self.symlink_target
 
617
            else:
 
618
                print >>output_to, '=== target is %r' % self.symlink_target
 
619
 
 
620
    def __init__(self, file_id, name, parent_id):
 
621
        super(InventoryLink, self).__init__(file_id, name, parent_id)
 
622
        self.kind = 'symlink'
 
623
 
 
624
    def kind_character(self):
 
625
        """See InventoryEntry.kind_character."""
 
626
        return ''
 
627
 
 
628
    def _put_in_tar(self, item, tree):
 
629
        """See InventoryEntry._put_in_tar."""
 
630
        iterm.type = tarfile.SYMTYPE
 
631
        fileobj = None
 
632
        item.size = 0
 
633
        item.mode = 0755
 
634
        item.linkname = self.symlink_target
 
635
        return fileobj
 
636
 
 
637
    def _put_on_disk(self, fullpath, tree):
 
638
        """See InventoryEntry._put_on_disk."""
 
639
        try:
 
640
            os.symlink(self.symlink_target, fullpath)
 
641
        except OSError,e:
 
642
            raise BzrError("Failed to create symlink %r -> %r, error: %s" % (fullpath, self.symlink_target, e))
 
643
 
 
644
    def _read_tree_state(self, path, work_tree):
 
645
        """See InventoryEntry._read_tree_state."""
 
646
        self.symlink_target = work_tree.get_symlink_target(self.file_id)
 
647
 
 
648
    def _unchanged(self, previous_ie):
 
649
        """See InventoryEntry._unchanged."""
 
650
        compatible = super(InventoryLink, self)._unchanged(previous_ie)
 
651
        if self.symlink_target != previous_ie.symlink_target:
 
652
            compatible = False
 
653
        return compatible
 
654
 
208
655
 
209
656
class Inventory(object):
210
657
    """Inventory of versioned files in a tree.
224
671
    inserted, other than through the Inventory API.
225
672
 
226
673
    >>> inv = Inventory()
227
 
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
228
 
    InventoryEntry('123-123', 'hello.c', kind='file', parent_id='TREE_ROOT')
 
674
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
 
675
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
229
676
    >>> inv['123-123'].name
230
677
    'hello.c'
231
678
 
241
688
    >>> [x[0] for x in inv.iter_entries()]
242
689
    ['hello.c']
243
690
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
244
 
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
245
 
    InventoryEntry('123-123', 'hello.c', kind='file', parent_id='TREE_ROOT-12345678-12345678')
 
691
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
 
692
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
246
693
    """
247
694
    def __init__(self, root_id=ROOT_ID):
248
695
        """Create or read an inventory.
262
709
        self._byid = {self.root.file_id: self.root}
263
710
 
264
711
 
 
712
    def copy(self):
 
713
        other = Inventory(self.root.file_id)
 
714
        # copy recursively so we know directories will be added before
 
715
        # their children.  There are more efficient ways than this...
 
716
        for path, entry in self.iter_entries():
 
717
            if entry == self.root:
 
718
                continue
 
719
            other.add(entry.copy())
 
720
        return other
 
721
 
 
722
 
265
723
    def __iter__(self):
266
724
        return iter(self._byid)
267
725
 
329
787
        """True if this entry contains a file with given id.
330
788
 
331
789
        >>> inv = Inventory()
332
 
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
333
 
        InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
 
790
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
 
791
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
334
792
        >>> '123' in inv
335
793
        True
336
794
        >>> '456' in inv
343
801
        """Return the entry for given file_id.
344
802
 
345
803
        >>> inv = Inventory()
346
 
        >>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
347
 
        InventoryEntry('123123', 'hello.c', kind='file', parent_id='TREE_ROOT')
 
804
        >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
 
805
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
348
806
        >>> inv['123123'].name
349
807
        'hello.c'
350
808
        """
412
870
        if parent_id == None:
413
871
            raise NotVersionedError(parent_path)
414
872
 
415
 
        ie = InventoryEntry(file_id, parts[-1],
416
 
                            kind=kind, parent_id=parent_id)
 
873
        if kind == 'directory':
 
874
            ie = InventoryDirectory(file_id, parts[-1], parent_id)
 
875
        elif kind == 'file':
 
876
            ie = InventoryFile(file_id, parts[-1], parent_id)
 
877
        elif kind == 'symlink':
 
878
            ie = InventoryLink(file_id, parts[-1], parent_id)
 
879
        else:
 
880
            raise BzrError("unknown kind %r" % kind)
417
881
        return self.add(ie)
418
882
 
419
883
 
421
885
        """Remove entry by id.
422
886
 
423
887
        >>> inv = Inventory()
424
 
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
425
 
        InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
 
888
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
 
889
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
426
890
        >>> '123' in inv
427
891
        True
428
892
        >>> del inv['123']
451
915
        >>> i2 = Inventory()
452
916
        >>> i1 == i2
453
917
        True
454
 
        >>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
455
 
        InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
 
918
        >>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
 
919
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
456
920
        >>> i1 == i2
457
921
        False
458
 
        >>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
459
 
        InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
 
922
        >>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
 
923
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
460
924
        >>> i1 == i2
461
925
        True
462
926
        """
471
935
 
472
936
 
473
937
    def __ne__(self, other):
474
 
        return not (self == other)
 
938
        return not self.__eq__(other)
475
939
 
476
940
 
477
941
    def __hash__(self):
498
962
 
499
963
 
500
964
    def id2path(self, file_id):
501
 
        """Return as a list the path to file_id."""
502
 
 
 
965
        """Return as a list the path to file_id.
 
966
        
 
967
        >>> i = Inventory()
 
968
        >>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))
 
969
        >>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))
 
970
        >>> print i.id2path('foo-id').replace(os.sep, '/')
 
971
        src/foo.c
 
972
        """
503
973
        # get all names, skipping root
504
974
        p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
505
975
        return os.sep.join(p)