/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Robert Collins
  • Date: 2005-10-07 06:13:14 UTC
  • mto: This revision was merged to the branch mainline in revision 1420.
  • Revision ID: robertc@robertcollins.net-20051007061313-9a835e979434e721
use transactions in the weave store interface, which enables caching for log

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
 
    >>> i.add(InventoryEntry('2323', 'hello.c', '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')
59
79
    >>> for j in i.iter_entries():
60
80
    ...   print j
61
81
    ... 
62
 
    ('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
63
 
    ('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
64
 
    >>> 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'))
65
85
    Traceback (most recent call last):
66
86
    ...
67
87
    BzrError: inventory already contains entry with id {2323}
68
 
    >>> i.add(InventoryEntry('2324', 'bye.c', 'file', '123'))
69
 
    >>> i.add(InventoryEntry('2325', 'wibble', 'directory', '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')
70
92
    >>> i.path2id('src/wibble')
71
93
    '2325'
72
94
    >>> '2325' in i
73
95
    True
74
 
    >>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
 
96
    >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
 
97
    InventoryFile('2326', 'wibble.c', parent_id='2325')
75
98
    >>> i['2326']
76
 
    InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
77
 
    >>> for j in i.iter_entries():
78
 
    ...     print j[0]
79
 
    ...     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)
80
103
    ... 
81
104
    src
82
105
    src/bye.c
83
106
    src/hello.c
84
107
    src/wibble
85
108
    src/wibble/wibble.c
86
 
    >>> i.id2path('2326')
 
109
    >>> i.id2path('2326').replace('\\\\', '/')
87
110
    'src/wibble/wibble.c'
88
 
 
89
 
    TODO: Maybe also keep the full path of the entry, and the children?
90
 
           But those depend on its position within a particular inventory, and
91
 
           it would be nice not to need to hold the backpointer here.
92
111
    """
93
 
 
94
 
    # TODO: split InventoryEntry into subclasses for files,
95
 
    # directories, etc etc.
96
 
 
 
112
    
97
113
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
98
 
                 'text_id', 'parent_id', 'children', ]
99
 
 
100
 
    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.id2path(self.file_id), 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.id2path(to_entry.file_id),
 
142
                                      to_tree)
 
143
        self._diff(text_diff, from_label, tree, to_label, to_entry, to_tree,
 
144
                   output_to, reverse)
 
145
 
 
146
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
147
             output_to, reverse=False):
 
148
        """Perform a diff between two entries of the same kind."""
 
149
 
 
150
    def find_previous_heads(self, previous_inventories, entry_weave):
 
151
        """Return the revisions and entries that directly preceed this.
 
152
 
 
153
        Returned as a map from revision to inventory entry.
 
154
 
 
155
        This is a map containing the file revisions in all parents
 
156
        for which the file exists, and its revision is not a parent of
 
157
        any other. If the file is new, the set will be empty.
 
158
        """
 
159
        def get_ancestors(weave, entry):
 
160
            return set(map(weave.idx_to_name,
 
161
                           weave.inclusions([weave.lookup(entry.revision)])))
 
162
        heads = {}
 
163
        head_ancestors = {}
 
164
        for inv in previous_inventories:
 
165
            if self.file_id in inv:
 
166
                ie = inv[self.file_id]
 
167
                assert ie.file_id == self.file_id
 
168
                if ie.revision in heads:
 
169
                    assert heads[ie.revision] == ie
 
170
                else:
 
171
                    # may want to add it.
 
172
                    # may already be covered:
 
173
                    already_present = 0 != len(
 
174
                        [head for head in heads 
 
175
                         if ie.revision in head_ancestors[head]])
 
176
                    if already_present:
 
177
                        # an ancestor of a known head.
 
178
                        continue
 
179
                    # definately a head:
 
180
                    ancestors = get_ancestors(entry_weave, ie)
 
181
                    # may knock something else out:
 
182
                    check_heads = list(heads.keys())
 
183
                    for head in check_heads:
 
184
                        if head in ancestors:
 
185
                            # this head is not really a head
 
186
                            heads.pop(head)
 
187
                    head_ancestors[ie.revision] = ancestors
 
188
                    heads[ie.revision] = ie
 
189
        return heads
 
190
 
 
191
    def get_tar_item(self, root, dp, now, tree):
 
192
        """Get a tarfile item and a file stream for its content."""
 
193
        item = tarfile.TarInfo(os.path.join(root, dp))
 
194
        # TODO: would be cool to actually set it to the timestamp of the
 
195
        # revision it was last changed
 
196
        item.mtime = now
 
197
        fileobj = self._put_in_tar(item, tree)
 
198
        return item, fileobj
 
199
 
 
200
    def has_text(self):
 
201
        """Return true if the object this entry represents has textual data.
 
202
 
 
203
        Note that textual data includes binary content.
 
204
 
 
205
        Also note that all entries get weave files created for them.
 
206
        This attribute is primarily used when upgrading from old trees that
 
207
        did not have the weave index for all inventory entries.
 
208
        """
 
209
        return False
 
210
 
 
211
    def __init__(self, file_id, name, parent_id, text_id=None):
101
212
        """Create an InventoryEntry
102
213
        
103
214
        The filename must be a single component, relative to the
104
215
        parent directory; it cannot be a whole path or relative name.
105
216
 
106
 
        >>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
 
217
        >>> e = InventoryFile('123', 'hello.c', ROOT_ID)
107
218
        >>> e.name
108
219
        'hello.c'
109
220
        >>> e.file_id
110
221
        '123'
111
 
        >>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
 
222
        >>> e = InventoryFile('123', 'src/hello.c', ROOT_ID)
112
223
        Traceback (most recent call last):
113
224
        BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
114
225
        """
 
226
        assert isinstance(name, basestring), name
115
227
        if '/' in name or '\\' in name:
116
228
            raise BzrCheckError('InventoryEntry name %r is invalid' % name)
117
229
        
 
230
        self.executable = False
 
231
        self.revision = None
118
232
        self.text_sha1 = None
119
233
        self.text_size = None
120
 
    
121
234
        self.file_id = file_id
122
235
        self.name = name
123
 
        self.kind = kind
124
236
        self.text_id = text_id
125
237
        self.parent_id = parent_id
126
 
        if kind == 'directory':
127
 
            self.children = {}
128
 
        elif kind == 'file':
129
 
            pass
130
 
        else:
131
 
            raise BzrError("unhandled entry kind %r" % kind)
132
 
 
133
 
 
 
238
        self.symlink_target = None
 
239
 
 
240
    def kind_character(self):
 
241
        """Return a short kind indicator useful for appending to names."""
 
242
        raise BzrError('unknown kind %r' % self.kind)
 
243
 
 
244
    known_kinds = ('file', 'directory', 'symlink', 'root_directory')
 
245
 
 
246
    def _put_in_tar(self, item, tree):
 
247
        """populate item for stashing in a tar, and return the content stream.
 
248
 
 
249
        If no content is available, return None.
 
250
        """
 
251
        raise BzrError("don't know how to export {%s} of kind %r" %
 
252
                       (self.file_id, self.kind))
 
253
 
 
254
    def put_on_disk(self, dest, dp, tree):
 
255
        """Create a representation of self on disk in the prefix dest.
 
256
        
 
257
        This is a template method - implement _put_on_disk in subclasses.
 
258
        """
 
259
        fullpath = appendpath(dest, dp)
 
260
        self._put_on_disk(fullpath, tree)
 
261
        mutter("  export {%s} kind %s to %s" % (self.file_id, self.kind, fullpath))
 
262
 
 
263
    def _put_on_disk(self, fullpath, tree):
 
264
        """Put this entry onto disk at fullpath, from tree tree."""
 
265
        raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
134
266
 
135
267
    def sorted_children(self):
136
268
        l = self.children.items()
137
269
        l.sort()
138
270
        return l
139
271
 
 
272
    @staticmethod
 
273
    def versionable_kind(kind):
 
274
        return kind in ('file', 'directory', 'symlink')
 
275
 
 
276
    def check(self, checker, rev_id, inv, tree):
 
277
        """Check this inventory entry is intact.
 
278
 
 
279
        This is a template method, override _check for kind specific
 
280
        tests.
 
281
        """
 
282
        if self.parent_id != None:
 
283
            if not inv.has_id(self.parent_id):
 
284
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
 
285
                        % (self.parent_id, rev_id))
 
286
        self._check(checker, rev_id, tree)
 
287
 
 
288
    def _check(self, checker, rev_id, tree):
 
289
        """Check this inventory entry for kind specific errors."""
 
290
        raise BzrCheckError('unknown entry kind %r in revision {%s}' % 
 
291
                            (self.kind, rev_id))
 
292
 
140
293
 
141
294
    def copy(self):
142
 
        other = InventoryEntry(self.file_id, self.name, self.kind,
143
 
                               self.parent_id, text_id=self.text_id)
144
 
        other.text_sha1 = self.text_sha1
145
 
        other.text_size = self.text_size
146
 
        # note that children are *not* copied; they're pulled across when
147
 
        # others are added
148
 
        return other
 
295
        """Clone this inventory entry."""
 
296
        raise NotImplementedError
149
297
 
 
298
    def _get_snapshot_change(self, previous_entries):
 
299
        if len(previous_entries) > 1:
 
300
            return 'merged'
 
301
        elif len(previous_entries) == 0:
 
302
            return 'added'
 
303
        else:
 
304
            return 'modified/renamed/reparented'
150
305
 
151
306
    def __repr__(self):
152
 
        return ("%s(%r, %r, kind=%r, parent_id=%r)"
 
307
        return ("%s(%r, %r, parent_id=%r)"
153
308
                % (self.__class__.__name__,
154
309
                   self.file_id,
155
310
                   self.name,
156
 
                   self.kind,
157
311
                   self.parent_id))
158
312
 
159
 
    
160
 
    def to_element(self):
161
 
        """Convert to XML element"""
162
 
        from bzrlib.xml import Element
163
 
        
164
 
        e = Element('entry')
165
 
 
166
 
        e.set('name', self.name)
167
 
        e.set('file_id', self.file_id)
168
 
        e.set('kind', self.kind)
169
 
 
170
 
        if self.text_size != None:
171
 
            e.set('text_size', '%d' % self.text_size)
172
 
            
173
 
        for f in ['text_id', 'text_sha1']:
174
 
            v = getattr(self, f)
175
 
            if v != None:
176
 
                e.set(f, v)
177
 
 
178
 
        # to be conservative, we don't externalize the root pointers
179
 
        # for now, leaving them as null in the xml form.  in a future
180
 
        # version it will be implied by nested elements.
181
 
        if self.parent_id != ROOT_ID:
182
 
            assert isinstance(self.parent_id, basestring)
183
 
            e.set('parent_id', self.parent_id)
184
 
 
185
 
        e.tail = '\n'
186
 
            
187
 
        return e
188
 
 
189
 
 
190
 
    def from_element(cls, elt):
191
 
        assert elt.tag == 'entry'
192
 
 
193
 
        ## original format inventories don't have a parent_id for
194
 
        ## nodes in the root directory, but it's cleaner to use one
195
 
        ## internally.
196
 
        parent_id = elt.get('parent_id')
197
 
        if parent_id == None:
198
 
            parent_id = ROOT_ID
199
 
 
200
 
        self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'), parent_id)
201
 
        self.text_id = elt.get('text_id')
202
 
        self.text_sha1 = elt.get('text_sha1')
203
 
        
204
 
        ## mutter("read inventoryentry: %r" % (elt.attrib))
205
 
 
206
 
        v = elt.get('text_size')
207
 
        self.text_size = v and int(v)
208
 
 
209
 
        return self
210
 
            
211
 
 
212
 
    from_element = classmethod(from_element)
 
313
    def snapshot(self, revision, path, previous_entries,
 
314
                 work_tree, weave_store, transaction):
 
315
        """Make a snapshot of this entry which may or may not have changed.
 
316
        
 
317
        This means that all its fields are populated, that it has its
 
318
        text stored in the text store or weave.
 
319
        """
 
320
        mutter('new parents of %s are %r', path, previous_entries)
 
321
        self._read_tree_state(path, work_tree)
 
322
        if len(previous_entries) == 1:
 
323
            # cannot be unchanged unless there is only one parent file rev.
 
324
            parent_ie = previous_entries.values()[0]
 
325
            if self._unchanged(parent_ie):
 
326
                mutter("found unchanged entry")
 
327
                self.revision = parent_ie.revision
 
328
                return "unchanged"
 
329
        return self.snapshot_revision(revision, previous_entries, 
 
330
                                      work_tree, weave_store, transaction)
 
331
 
 
332
    def snapshot_revision(self, revision, previous_entries, work_tree,
 
333
                          weave_store, transaction):
 
334
        """Record this revision unconditionally."""
 
335
        mutter('new revision for {%s}', self.file_id)
 
336
        self.revision = revision
 
337
        change = self._get_snapshot_change(previous_entries)
 
338
        self._snapshot_text(previous_entries, work_tree, weave_store,
 
339
                            transaction)
 
340
        return change
 
341
 
 
342
    def _snapshot_text(self, file_parents, work_tree, weave_store, transaction): 
 
343
        """Record the 'text' of this entry, whatever form that takes.
 
344
        
 
345
        This default implementation simply adds an empty text.
 
346
        """
 
347
        mutter('storing file {%s} in revision {%s}',
 
348
               self.file_id, self.revision)
 
349
        self._add_text_to_weave([], file_parents, weave_store, transaction)
213
350
 
214
351
    def __eq__(self, other):
215
352
        if not isinstance(other, InventoryEntry):
216
353
            return NotImplemented
217
354
 
218
 
        return (self.file_id == other.file_id) \
219
 
               and (self.name == other.name) \
220
 
               and (self.text_sha1 == other.text_sha1) \
221
 
               and (self.text_size == other.text_size) \
222
 
               and (self.text_id == other.text_id) \
223
 
               and (self.parent_id == other.parent_id) \
224
 
               and (self.kind == other.kind)
225
 
 
 
355
        return ((self.file_id == other.file_id)
 
356
                and (self.name == other.name)
 
357
                and (other.symlink_target == self.symlink_target)
 
358
                and (self.text_sha1 == other.text_sha1)
 
359
                and (self.text_size == other.text_size)
 
360
                and (self.text_id == other.text_id)
 
361
                and (self.parent_id == other.parent_id)
 
362
                and (self.kind == other.kind)
 
363
                and (self.revision == other.revision)
 
364
                and (self.executable == other.executable)
 
365
                )
226
366
 
227
367
    def __ne__(self, other):
228
368
        return not (self == other)
230
370
    def __hash__(self):
231
371
        raise ValueError('not hashable')
232
372
 
 
373
    def _unchanged(self, previous_ie):
 
374
        """Has this entry changed relative to previous_ie.
 
375
 
 
376
        This method should be overriden in child classes.
 
377
        """
 
378
        compatible = True
 
379
        # different inv parent
 
380
        if previous_ie.parent_id != self.parent_id:
 
381
            compatible = False
 
382
        # renamed
 
383
        elif previous_ie.name != self.name:
 
384
            compatible = False
 
385
        return compatible
 
386
 
 
387
    def _read_tree_state(self, path, work_tree):
 
388
        """Populate fields in the inventory entry from the given tree.
 
389
        
 
390
        Note that this should be modified to be a noop on virtual trees
 
391
        as all entries created there are prepopulated.
 
392
        """
233
393
 
234
394
 
235
395
class RootEntry(InventoryEntry):
 
396
 
 
397
    def _check(self, checker, rev_id, tree):
 
398
        """See InventoryEntry._check"""
 
399
 
236
400
    def __init__(self, file_id):
237
401
        self.file_id = file_id
238
402
        self.children = {}
248
412
               and (self.children == other.children)
249
413
 
250
414
 
 
415
class InventoryDirectory(InventoryEntry):
 
416
    """A directory in an inventory."""
 
417
 
 
418
    def _check(self, checker, rev_id, tree):
 
419
        """See InventoryEntry._check"""
 
420
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
 
421
            raise BzrCheckError('directory {%s} has text in revision {%s}'
 
422
                                % (self.file_id, rev_id))
 
423
 
 
424
    def copy(self):
 
425
        other = InventoryDirectory(self.file_id, self.name, self.parent_id)
 
426
        other.revision = self.revision
 
427
        # note that children are *not* copied; they're pulled across when
 
428
        # others are added
 
429
        return other
 
430
 
 
431
    def __init__(self, file_id, name, parent_id):
 
432
        super(InventoryDirectory, self).__init__(file_id, name, parent_id)
 
433
        self.children = {}
 
434
        self.kind = 'directory'
 
435
 
 
436
    def kind_character(self):
 
437
        """See InventoryEntry.kind_character."""
 
438
        return '/'
 
439
 
 
440
    def _put_in_tar(self, item, tree):
 
441
        """See InventoryEntry._put_in_tar."""
 
442
        item.type = tarfile.DIRTYPE
 
443
        fileobj = None
 
444
        item.name += '/'
 
445
        item.size = 0
 
446
        item.mode = 0755
 
447
        return fileobj
 
448
 
 
449
    def _put_on_disk(self, fullpath, tree):
 
450
        """See InventoryEntry._put_on_disk."""
 
451
        os.mkdir(fullpath)
 
452
 
 
453
 
 
454
class InventoryFile(InventoryEntry):
 
455
    """A file in an inventory."""
 
456
 
 
457
    def _check(self, checker, rev_id, tree):
 
458
        """See InventoryEntry._check"""
 
459
        revision = self.revision
 
460
        t = (self.file_id, revision)
 
461
        if t in checker.checked_texts:
 
462
            prev_sha = checker.checked_texts[t] 
 
463
            if prev_sha != self.text_sha1:
 
464
                raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
 
465
                                    (self.file_id, rev_id))
 
466
            else:
 
467
                checker.repeated_text_cnt += 1
 
468
                return
 
469
        mutter('check version {%s} of {%s}', rev_id, self.file_id)
 
470
        file_lines = tree.get_file_lines(self.file_id)
 
471
        checker.checked_text_cnt += 1 
 
472
        if self.text_size != sum(map(len, file_lines)):
 
473
            raise BzrCheckError('text {%s} wrong size' % self.text_id)
 
474
        if self.text_sha1 != sha_strings(file_lines):
 
475
            raise BzrCheckError('text {%s} wrong sha1' % self.text_id)
 
476
        checker.checked_texts[t] = self.text_sha1
 
477
 
 
478
    def copy(self):
 
479
        other = InventoryFile(self.file_id, self.name, self.parent_id)
 
480
        other.executable = self.executable
 
481
        other.text_id = self.text_id
 
482
        other.text_sha1 = self.text_sha1
 
483
        other.text_size = self.text_size
 
484
        other.revision = self.revision
 
485
        return other
 
486
 
 
487
    def detect_changes(self, old_entry):
 
488
        """See InventoryEntry.detect_changes."""
 
489
        assert self.text_sha1 != None
 
490
        assert old_entry.text_sha1 != None
 
491
        text_modified = (self.text_sha1 != old_entry.text_sha1)
 
492
        meta_modified = (self.executable != old_entry.executable)
 
493
        return text_modified, meta_modified
 
494
 
 
495
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
496
             output_to, reverse=False):
 
497
        """See InventoryEntry._diff."""
 
498
        from_text = tree.get_file(self.file_id).readlines()
 
499
        if to_entry:
 
500
            to_text = to_tree.get_file(to_entry.file_id).readlines()
 
501
        else:
 
502
            to_text = []
 
503
        if not reverse:
 
504
            text_diff(from_label, from_text,
 
505
                      to_label, to_text, output_to)
 
506
        else:
 
507
            text_diff(to_label, to_text,
 
508
                      from_label, from_text, output_to)
 
509
 
 
510
    def has_text(self):
 
511
        """See InventoryEntry.has_text."""
 
512
        return True
 
513
 
 
514
    def __init__(self, file_id, name, parent_id):
 
515
        super(InventoryFile, self).__init__(file_id, name, parent_id)
 
516
        self.kind = 'file'
 
517
 
 
518
    def kind_character(self):
 
519
        """See InventoryEntry.kind_character."""
 
520
        return ''
 
521
 
 
522
    def _put_in_tar(self, item, tree):
 
523
        """See InventoryEntry._put_in_tar."""
 
524
        item.type = tarfile.REGTYPE
 
525
        fileobj = tree.get_file(self.file_id)
 
526
        item.size = self.text_size
 
527
        if tree.is_executable(self.file_id):
 
528
            item.mode = 0755
 
529
        else:
 
530
            item.mode = 0644
 
531
        return fileobj
 
532
 
 
533
    def _put_on_disk(self, fullpath, tree):
 
534
        """See InventoryEntry._put_on_disk."""
 
535
        pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
 
536
        if tree.is_executable(self.file_id):
 
537
            os.chmod(fullpath, 0755)
 
538
 
 
539
    def _read_tree_state(self, path, work_tree):
 
540
        """See InventoryEntry._read_tree_state."""
 
541
        self.text_sha1 = work_tree.get_file_sha1(self.file_id)
 
542
        self.executable = work_tree.is_executable(self.file_id)
 
543
 
 
544
    def _snapshot_text(self, file_parents, work_tree, weave_store, transaction):
 
545
        """See InventoryEntry._snapshot_text."""
 
546
        mutter('storing file {%s} in revision {%s}',
 
547
               self.file_id, self.revision)
 
548
        # special case to avoid diffing on renames or 
 
549
        # reparenting
 
550
        if (len(file_parents) == 1
 
551
            and self.text_sha1 == file_parents.values()[0].text_sha1
 
552
            and self.text_size == file_parents.values()[0].text_size):
 
553
            previous_ie = file_parents.values()[0]
 
554
            weave_store.add_identical_text(
 
555
                self.file_id, previous_ie.revision, 
 
556
                self.revision, file_parents, transaction)
 
557
        else:
 
558
            new_lines = work_tree.get_file(self.file_id).readlines()
 
559
            self._add_text_to_weave(new_lines, file_parents, weave_store,
 
560
                                    transaction)
 
561
            self.text_sha1 = sha_strings(new_lines)
 
562
            self.text_size = sum(map(len, new_lines))
 
563
 
 
564
 
 
565
    def _unchanged(self, previous_ie):
 
566
        """See InventoryEntry._unchanged."""
 
567
        compatible = super(InventoryFile, self)._unchanged(previous_ie)
 
568
        if self.text_sha1 != previous_ie.text_sha1:
 
569
            compatible = False
 
570
        else:
 
571
            # FIXME: 20050930 probe for the text size when getting sha1
 
572
            # in _read_tree_state
 
573
            self.text_size = previous_ie.text_size
 
574
        return compatible
 
575
 
 
576
 
 
577
class InventoryLink(InventoryEntry):
 
578
    """A file in an inventory."""
 
579
 
 
580
    __slots__ = ['symlink_target']
 
581
 
 
582
    def _check(self, checker, rev_id, tree):
 
583
        """See InventoryEntry._check"""
 
584
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
 
585
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
 
586
                    % (self.file_id, rev_id))
 
587
        if self.symlink_target == None:
 
588
            raise BzrCheckError('symlink {%s} has no target in revision {%s}'
 
589
                    % (self.file_id, rev_id))
 
590
 
 
591
    def copy(self):
 
592
        other = InventoryLink(self.file_id, self.name, self.parent_id)
 
593
        other.symlink_target = self.symlink_target
 
594
        other.revision = self.revision
 
595
        return other
 
596
 
 
597
    def detect_changes(self, old_entry):
 
598
        """See InventoryEntry.detect_changes."""
 
599
        # FIXME: which _modified field should we use ? RBC 20051003
 
600
        text_modified = (self.symlink_target != old_entry.symlink_target)
 
601
        if text_modified:
 
602
            mutter("    symlink target changed")
 
603
        meta_modified = False
 
604
        return text_modified, meta_modified
 
605
 
 
606
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
607
             output_to, reverse=False):
 
608
        """See InventoryEntry._diff."""
 
609
        from_text = self.symlink_target
 
610
        if to_entry is not None:
 
611
            to_text = to_entry.symlink_target
 
612
            if reverse:
 
613
                temp = from_text
 
614
                from_text = to_text
 
615
                to_text = temp
 
616
            print >>output_to, '=== target changed %r => %r' % (from_text, to_text)
 
617
        else:
 
618
            if not reverse:
 
619
                print >>output_to, '=== target was %r' % self.symlink_target
 
620
            else:
 
621
                print >>output_to, '=== target is %r' % self.symlink_target
 
622
 
 
623
    def __init__(self, file_id, name, parent_id):
 
624
        super(InventoryLink, self).__init__(file_id, name, parent_id)
 
625
        self.kind = 'symlink'
 
626
 
 
627
    def kind_character(self):
 
628
        """See InventoryEntry.kind_character."""
 
629
        return ''
 
630
 
 
631
    def _put_in_tar(self, item, tree):
 
632
        """See InventoryEntry._put_in_tar."""
 
633
        iterm.type = tarfile.SYMTYPE
 
634
        fileobj = None
 
635
        item.size = 0
 
636
        item.mode = 0755
 
637
        item.linkname = self.symlink_target
 
638
        return fileobj
 
639
 
 
640
    def _put_on_disk(self, fullpath, tree):
 
641
        """See InventoryEntry._put_on_disk."""
 
642
        try:
 
643
            os.symlink(self.symlink_target, fullpath)
 
644
        except OSError,e:
 
645
            raise BzrError("Failed to create symlink %r -> %r, error: %s" % (fullpath, self.symlink_target, e))
 
646
 
 
647
    def _read_tree_state(self, path, work_tree):
 
648
        """See InventoryEntry._read_tree_state."""
 
649
        self.symlink_target = work_tree.get_symlink_target(self.file_id)
 
650
 
 
651
    def _unchanged(self, previous_ie):
 
652
        """See InventoryEntry._unchanged."""
 
653
        compatible = super(InventoryLink, self)._unchanged(previous_ie)
 
654
        if self.symlink_target != previous_ie.symlink_target:
 
655
            compatible = False
 
656
        return compatible
 
657
 
251
658
 
252
659
class Inventory(object):
253
660
    """Inventory of versioned files in a tree.
267
674
    inserted, other than through the Inventory API.
268
675
 
269
676
    >>> inv = Inventory()
270
 
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
 
677
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
 
678
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
271
679
    >>> inv['123-123'].name
272
680
    'hello.c'
273
681
 
283
691
    >>> [x[0] for x in inv.iter_entries()]
284
692
    ['hello.c']
285
693
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
286
 
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
 
694
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
 
695
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
287
696
    """
288
697
    def __init__(self, root_id=ROOT_ID):
289
698
        """Create or read an inventory.
295
704
        The inventory is created with a default root directory, with
296
705
        an id of None.
297
706
        """
298
 
        # We are letting Branch(init=True) create a unique inventory
 
707
        # We are letting Branch.initialize() create a unique inventory
299
708
        # root id. Rather than generating a random one here.
300
709
        #if root_id is None:
301
710
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
303
712
        self._byid = {self.root.file_id: self.root}
304
713
 
305
714
 
 
715
    def copy(self):
 
716
        other = Inventory(self.root.file_id)
 
717
        # copy recursively so we know directories will be added before
 
718
        # their children.  There are more efficient ways than this...
 
719
        for path, entry in self.iter_entries():
 
720
            if entry == self.root:
 
721
                continue
 
722
            other.add(entry.copy())
 
723
        return other
 
724
 
 
725
 
306
726
    def __iter__(self):
307
727
        return iter(self._byid)
308
728
 
370
790
        """True if this entry contains a file with given id.
371
791
 
372
792
        >>> inv = Inventory()
373
 
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
 
793
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
 
794
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
374
795
        >>> '123' in inv
375
796
        True
376
797
        >>> '456' in inv
383
804
        """Return the entry for given file_id.
384
805
 
385
806
        >>> inv = Inventory()
386
 
        >>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
 
807
        >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
 
808
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
387
809
        >>> inv['123123'].name
388
810
        'hello.c'
389
811
        """
407
829
        """Add entry to inventory.
408
830
 
409
831
        To add  a file to a branch ready to be committed, use Branch.add,
410
 
        which calls this."""
 
832
        which calls this.
 
833
 
 
834
        Returns the new entry object.
 
835
        """
411
836
        if entry.file_id in self._byid:
412
837
            raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
413
838
 
425
850
 
426
851
        self._byid[entry.file_id] = entry
427
852
        parent.children[entry.name] = entry
 
853
        return entry
428
854
 
429
855
 
430
856
    def add_path(self, relpath, kind, file_id=None):
431
857
        """Add entry from a path.
432
858
 
433
 
        The immediate parent must already be versioned"""
 
859
        The immediate parent must already be versioned.
 
860
 
 
861
        Returns the new entry object."""
434
862
        from bzrlib.branch import gen_file_id
435
863
        
436
864
        parts = bzrlib.osutils.splitpath(relpath)
445
873
        if parent_id == None:
446
874
            raise NotVersionedError(parent_path)
447
875
 
448
 
        ie = InventoryEntry(file_id, parts[-1],
449
 
                            kind=kind, parent_id=parent_id)
 
876
        if kind == 'directory':
 
877
            ie = InventoryDirectory(file_id, parts[-1], parent_id)
 
878
        elif kind == 'file':
 
879
            ie = InventoryFile(file_id, parts[-1], parent_id)
 
880
        elif kind == 'symlink':
 
881
            ie = InventoryLink(file_id, parts[-1], parent_id)
 
882
        else:
 
883
            raise BzrError("unknown kind %r" % kind)
450
884
        return self.add(ie)
451
885
 
452
886
 
454
888
        """Remove entry by id.
455
889
 
456
890
        >>> inv = Inventory()
457
 
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
 
891
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
 
892
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
458
893
        >>> '123' in inv
459
894
        True
460
895
        >>> del inv['123']
476
911
        del self[ie.parent_id].children[ie.name]
477
912
 
478
913
 
479
 
    def to_element(self):
480
 
        """Convert to XML Element"""
481
 
        from bzrlib.xml import Element
482
 
        
483
 
        e = Element('inventory')
484
 
        e.text = '\n'
485
 
        if self.root.file_id not in (None, ROOT_ID):
486
 
            e.set('file_id', self.root.file_id)
487
 
        for path, ie in self.iter_entries():
488
 
            e.append(ie.to_element())
489
 
        return e
490
 
    
491
 
 
492
 
    def from_element(cls, elt):
493
 
        """Construct from XML Element
494
 
        
495
 
        >>> inv = Inventory()
496
 
        >>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c', 'file', ROOT_ID))
497
 
        >>> elt = inv.to_element()
498
 
        >>> inv2 = Inventory.from_element(elt)
499
 
        >>> inv2 == inv
500
 
        True
501
 
        """
502
 
        # XXXX: doctest doesn't run this properly under python2.3
503
 
        assert elt.tag == 'inventory'
504
 
        root_id = elt.get('file_id') or ROOT_ID
505
 
        o = cls(root_id)
506
 
        for e in elt:
507
 
            ie = InventoryEntry.from_element(e)
508
 
            if ie.parent_id == ROOT_ID:
509
 
                ie.parent_id = root_id
510
 
            o.add(ie)
511
 
        return o
512
 
        
513
 
    from_element = classmethod(from_element)
514
 
 
515
 
 
516
914
    def __eq__(self, other):
517
915
        """Compare two sets by comparing their contents.
518
916
 
520
918
        >>> i2 = Inventory()
521
919
        >>> i1 == i2
522
920
        True
523
 
        >>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
 
921
        >>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
 
922
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
524
923
        >>> i1 == i2
525
924
        False
526
 
        >>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
 
925
        >>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
 
926
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
527
927
        >>> i1 == i2
528
928
        True
529
929
        """
538
938
 
539
939
 
540
940
    def __ne__(self, other):
541
 
        return not (self == other)
 
941
        return not self.__eq__(other)
542
942
 
543
943
 
544
944
    def __hash__(self):
545
945
        raise ValueError('not hashable')
546
946
 
547
947
 
548
 
 
549
948
    def get_idpath(self, file_id):
550
949
        """Return a list of file_ids for the path to an entry.
551
950
 
566
965
 
567
966
 
568
967
    def id2path(self, file_id):
569
 
        """Return as a list the path to file_id."""
570
 
 
 
968
        """Return as a list the path to file_id.
 
969
        
 
970
        >>> i = Inventory()
 
971
        >>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))
 
972
        >>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))
 
973
        >>> print i.id2path('foo-id').replace(os.sep, '/')
 
974
        src/foo.c
 
975
        """
571
976
        # get all names, skipping root
572
977
        p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
573
978
        return os.sep.join(p)
644
1049
 
645
1050
 
646
1051
 
647
 
_NAME_RE = re.compile(r'^[^/\\]+$')
 
1052
_NAME_RE = None
648
1053
 
649
1054
def is_valid_name(name):
 
1055
    global _NAME_RE
 
1056
    if _NAME_RE == None:
 
1057
        _NAME_RE = re.compile(r'^[^/\\]+$')
 
1058
        
650
1059
    return bool(_NAME_RE.match(name))