← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Robert Collins
  • Date: 2006-01-05 22:30:59 UTC
  • mto: (1534.1.4 integration)
  • mto: This revision was merged to the branch mainline in revision 1536.
  • Revision ID: robertc@robertcollins.net-20060105223059-a8b64f7b47cf12fb
 * bzrlib.osutils.safe_unicode now exists to provide parameter coercion
   for functions that need unicode strings. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
16
16
 
 
17
# FIXME: This refactoring of the workingtree code doesn't seem to keep 
 
18
# the WorkingTree's copy of the inventory in sync with the branch.  The
 
19
# branch modifies its working inventory when it does a commit to make
 
20
# missing files permanently removed.
17
21
 
18
22
# TODO: Maybe also keep the full path of the entry, and the children?
19
23
# But those depend on its position within a particular inventory, and
20
24
# it would be nice not to need to hold the backpointer here.
21
25
 
22
 
# TODO: Perhaps split InventoryEntry into subclasses for files,
23
 
# directories, etc etc.
24
 
 
25
 
 
26
26
# This should really be an id randomly assigned when the tree is
27
27
# created, but it's not for now.
28
28
ROOT_ID = "TREE_ROOT"
29
29
 
30
30
 
31
 
import sys, os.path, types, re
 
31
import os.path
 
32
import re
 
33
import sys
 
34
import tarfile
 
35
import types
32
36
 
33
37
import bzrlib
34
 
from bzrlib.errors import BzrError, BzrCheckError
35
 
 
36
 
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
 
38
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
 
39
                            pathjoin, sha_strings)
37
40
from bzrlib.trace import mutter
38
 
from bzrlib.errors import NotVersionedError
39
 
        
 
41
from bzrlib.errors import (NotVersionedError, InvalidEntryName,
 
42
                           BzrError, BzrCheckError)
 
43
 
40
44
 
41
45
class InventoryEntry(object):
42
46
    """Description of a versioned file.
49
53
    name
50
54
        (within the parent directory)
51
55
 
52
 
    kind
53
 
        'directory' or 'file'
54
 
 
55
56
    parent_id
56
57
        file_id of the parent directory, or ROOT_ID
57
58
 
58
 
    entry_version
59
 
        the revision_id in which the name or parent of this file was
60
 
        last changed
 
59
    revision
 
60
        the revision_id in which this variation of this file was 
 
61
        introduced.
 
62
 
 
63
    executable
 
64
        Indicates that this file should be executable on systems
 
65
        that support it.
61
66
 
62
67
    text_sha1
63
68
        sha-1 of the text of the file
65
70
    text_size
66
71
        size in bytes of the text of the file
67
72
        
68
 
    text_version
69
 
        the revision_id in which the text of this file was introduced
70
 
 
71
73
    (reading a version 4 tree created a text_id field.)
72
74
 
73
75
    >>> i = Inventory()
74
76
    >>> i.path2id('')
75
77
    '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')
80
 
    >>> for j in i.iter_entries():
81
 
    ...   print j
 
78
    >>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
 
79
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT')
 
80
    >>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
 
81
    InventoryFile('2323', 'hello.c', parent_id='123')
 
82
    >>> shouldbe = {0: 'src', 1: pathjoin('src','hello.c')}
 
83
    >>> for ix, j in enumerate(i.iter_entries()):
 
84
    ...   print (j[0] == shouldbe[ix], j[1])
82
85
    ... 
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'))
 
86
    (True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT'))
 
87
    (True, InventoryFile('2323', 'hello.c', parent_id='123'))
 
88
    >>> i.add(InventoryFile('2323', 'bye.c', '123'))
86
89
    Traceback (most recent call last):
87
90
    ...
88
91
    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')
 
92
    >>> i.add(InventoryFile('2324', 'bye.c', '123'))
 
93
    InventoryFile('2324', 'bye.c', parent_id='123')
 
94
    >>> i.add(InventoryDirectory('2325', 'wibble', '123'))
 
95
    InventoryDirectory('2325', 'wibble', parent_id='123')
93
96
    >>> i.path2id('src/wibble')
94
97
    '2325'
95
98
    >>> '2325' in i
96
99
    True
97
 
    >>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
98
 
    InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
 
100
    >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
 
101
    InventoryFile('2326', 'wibble.c', parent_id='2325')
99
102
    >>> 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])
 
103
    InventoryFile('2326', 'wibble.c', parent_id='2325')
 
104
    >>> for path, entry in i.iter_entries():
 
105
    ...     print path
 
106
    ...     assert i.path2id(path)
104
107
    ... 
105
108
    src
106
109
    src/bye.c
112
115
    """
113
116
    
114
117
    __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):
 
118
                 'text_id', 'parent_id', 'children', 'executable', 
 
119
                 'revision']
 
120
 
 
121
    def _add_text_to_weave(self, new_lines, parents, weave_store, transaction):
 
122
        weave_store.add_text(self.file_id, self.revision, new_lines, parents,
 
123
                             transaction)
 
124
 
 
125
    def detect_changes(self, old_entry):
 
126
        """Return a (text_modified, meta_modified) from this to old_entry.
 
127
        
 
128
        _read_tree_state must have been called on self and old_entry prior to 
 
129
        calling detect_changes.
 
130
        """
 
131
        return False, False
 
132
 
 
133
    def diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
134
             output_to, reverse=False):
 
135
        """Perform a diff from this to to_entry.
 
136
 
 
137
        text_diff will be used for textual difference calculation.
 
138
        This is a template method, override _diff in child classes.
 
139
        """
 
140
        self._read_tree_state(tree.id2path(self.file_id), tree)
 
141
        if to_entry:
 
142
            # cannot diff from one kind to another - you must do a removal
 
143
            # and an addif they do not match.
 
144
            assert self.kind == to_entry.kind
 
145
            to_entry._read_tree_state(to_tree.id2path(to_entry.file_id),
 
146
                                      to_tree)
 
147
        self._diff(text_diff, from_label, tree, to_label, to_entry, to_tree,
 
148
                   output_to, reverse)
 
149
 
 
150
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
151
             output_to, reverse=False):
 
152
        """Perform a diff between two entries of the same kind."""
 
153
 
 
154
    def find_previous_heads(self, previous_inventories, entry_weave):
 
155
        """Return the revisions and entries that directly preceed this.
 
156
 
 
157
        Returned as a map from revision to inventory entry.
 
158
 
 
159
        This is a map containing the file revisions in all parents
 
160
        for which the file exists, and its revision is not a parent of
 
161
        any other. If the file is new, the set will be empty.
 
162
        """
 
163
        def get_ancestors(weave, entry):
 
164
            return set(map(weave.idx_to_name,
 
165
                           weave.inclusions([weave.lookup(entry.revision)])))
 
166
        heads = {}
 
167
        head_ancestors = {}
 
168
        for inv in previous_inventories:
 
169
            if self.file_id in inv:
 
170
                ie = inv[self.file_id]
 
171
                assert ie.file_id == self.file_id
 
172
                if ie.revision in heads:
 
173
                    # fixup logic, there was a bug in revision updates.
 
174
                    # with x bit support.
 
175
                    try:
 
176
                        if heads[ie.revision].executable != ie.executable:
 
177
                            heads[ie.revision].executable = False
 
178
                            ie.executable = False
 
179
                    except AttributeError:
 
180
                        pass
 
181
                    assert heads[ie.revision] == ie
 
182
                else:
 
183
                    # may want to add it.
 
184
                    # may already be covered:
 
185
                    already_present = 0 != len(
 
186
                        [head for head in heads 
 
187
                         if ie.revision in head_ancestors[head]])
 
188
                    if already_present:
 
189
                        # an ancestor of a known head.
 
190
                        continue
 
191
                    # definately a head:
 
192
                    ancestors = get_ancestors(entry_weave, ie)
 
193
                    # may knock something else out:
 
194
                    check_heads = list(heads.keys())
 
195
                    for head in check_heads:
 
196
                        if head in ancestors:
 
197
                            # this head is not really a head
 
198
                            heads.pop(head)
 
199
                    head_ancestors[ie.revision] = ancestors
 
200
                    heads[ie.revision] = ie
 
201
        return heads
 
202
 
 
203
    def get_tar_item(self, root, dp, now, tree):
 
204
        """Get a tarfile item and a file stream for its content."""
 
205
        item = tarfile.TarInfo(pathjoin(root, dp))
 
206
        # TODO: would be cool to actually set it to the timestamp of the
 
207
        # revision it was last changed
 
208
        item.mtime = now
 
209
        fileobj = self._put_in_tar(item, tree)
 
210
        return item, fileobj
 
211
 
 
212
    def has_text(self):
 
213
        """Return true if the object this entry represents has textual data.
 
214
 
 
215
        Note that textual data includes binary content.
 
216
 
 
217
        Also note that all entries get weave files created for them.
 
218
        This attribute is primarily used when upgrading from old trees that
 
219
        did not have the weave index for all inventory entries.
 
220
        """
 
221
        return False
 
222
 
 
223
    def __init__(self, file_id, name, parent_id, text_id=None):
120
224
        """Create an InventoryEntry
121
225
        
122
226
        The filename must be a single component, relative to the
123
227
        parent directory; it cannot be a whole path or relative name.
124
228
 
125
 
        >>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
 
229
        >>> e = InventoryFile('123', 'hello.c', ROOT_ID)
126
230
        >>> e.name
127
231
        'hello.c'
128
232
        >>> e.file_id
129
233
        '123'
130
 
        >>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
 
234
        >>> e = InventoryFile('123', 'src/hello.c', ROOT_ID)
131
235
        Traceback (most recent call last):
132
 
        BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
 
236
        InvalidEntryName: Invalid entry name: src/hello.c
133
237
        """
134
238
        assert isinstance(name, basestring), name
135
239
        if '/' in name or '\\' in name:
136
 
            raise BzrCheckError('InventoryEntry name %r is invalid' % name)
137
 
        
138
 
        self.text_version = None
139
 
        self.entry_version = None
 
240
            raise InvalidEntryName(name=name)
 
241
        self.executable = False
 
242
        self.revision = None
140
243
        self.text_sha1 = None
141
244
        self.text_size = None
142
245
        self.file_id = file_id
143
246
        self.name = name
144
 
        self.kind = kind
145
247
        self.text_id = text_id
146
248
        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
 
 
 
249
        self.symlink_target = None
 
250
 
 
251
    def kind_character(self):
 
252
        """Return a short kind indicator useful for appending to names."""
 
253
        raise BzrError('unknown kind %r' % self.kind)
 
254
 
 
255
    known_kinds = ('file', 'directory', 'symlink', 'root_directory')
 
256
 
 
257
    def _put_in_tar(self, item, tree):
 
258
        """populate item for stashing in a tar, and return the content stream.
 
259
 
 
260
        If no content is available, return None.
 
261
        """
 
262
        raise BzrError("don't know how to export {%s} of kind %r" %
 
263
                       (self.file_id, self.kind))
 
264
 
 
265
    def put_on_disk(self, dest, dp, tree):
 
266
        """Create a representation of self on disk in the prefix dest.
 
267
        
 
268
        This is a template method - implement _put_on_disk in subclasses.
 
269
        """
 
270
        fullpath = pathjoin(dest, dp)
 
271
        self._put_on_disk(fullpath, tree)
 
272
        mutter("  export {%s} kind %s to %s", self.file_id,
 
273
                self.kind, fullpath)
 
274
 
 
275
    def _put_on_disk(self, fullpath, tree):
 
276
        """Put this entry onto disk at fullpath, from tree tree."""
 
277
        raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
155
278
 
156
279
    def sorted_children(self):
157
280
        l = self.children.items()
158
281
        l.sort()
159
282
        return l
160
283
 
 
284
    @staticmethod
 
285
    def versionable_kind(kind):
 
286
        return kind in ('file', 'directory', 'symlink')
 
287
 
 
288
    def check(self, checker, rev_id, inv, tree):
 
289
        """Check this inventory entry is intact.
 
290
 
 
291
        This is a template method, override _check for kind specific
 
292
        tests.
 
293
        """
 
294
        if self.parent_id != None:
 
295
            if not inv.has_id(self.parent_id):
 
296
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
 
297
                        % (self.parent_id, rev_id))
 
298
        self._check(checker, rev_id, tree)
 
299
 
 
300
    def _check(self, checker, rev_id, tree):
 
301
        """Check this inventory entry for kind specific errors."""
 
302
        raise BzrCheckError('unknown entry kind %r in revision {%s}' % 
 
303
                            (self.kind, rev_id))
 
304
 
161
305
 
162
306
    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
 
307
        """Clone this inventory entry."""
 
308
        raise NotImplementedError
172
309
 
 
310
    def _get_snapshot_change(self, previous_entries):
 
311
        if len(previous_entries) > 1:
 
312
            return 'merged'
 
313
        elif len(previous_entries) == 0:
 
314
            return 'added'
 
315
        else:
 
316
            return 'modified/renamed/reparented'
173
317
 
174
318
    def __repr__(self):
175
 
        return ("%s(%r, %r, kind=%r, parent_id=%r)"
 
319
        return ("%s(%r, %r, parent_id=%r)"
176
320
                % (self.__class__.__name__,
177
321
                   self.file_id,
178
322
                   self.name,
179
 
                   self.kind,
180
323
                   self.parent_id))
181
324
 
182
 
    
 
325
    def snapshot(self, revision, path, previous_entries,
 
326
                 work_tree, weave_store, transaction):
 
327
        """Make a snapshot of this entry which may or may not have changed.
 
328
        
 
329
        This means that all its fields are populated, that it has its
 
330
        text stored in the text store or weave.
 
331
        """
 
332
        mutter('new parents of %s are %r', path, previous_entries)
 
333
        self._read_tree_state(path, work_tree)
 
334
        if len(previous_entries) == 1:
 
335
            # cannot be unchanged unless there is only one parent file rev.
 
336
            parent_ie = previous_entries.values()[0]
 
337
            if self._unchanged(parent_ie):
 
338
                mutter("found unchanged entry")
 
339
                self.revision = parent_ie.revision
 
340
                return "unchanged"
 
341
        return self.snapshot_revision(revision, previous_entries, 
 
342
                                      work_tree, weave_store, transaction)
 
343
 
 
344
    def snapshot_revision(self, revision, previous_entries, work_tree,
 
345
                          weave_store, transaction):
 
346
        """Record this revision unconditionally."""
 
347
        mutter('new revision for {%s}', self.file_id)
 
348
        self.revision = revision
 
349
        change = self._get_snapshot_change(previous_entries)
 
350
        self._snapshot_text(previous_entries, work_tree, weave_store,
 
351
                            transaction)
 
352
        return change
 
353
 
 
354
    def _snapshot_text(self, file_parents, work_tree, weave_store, transaction): 
 
355
        """Record the 'text' of this entry, whatever form that takes.
 
356
        
 
357
        This default implementation simply adds an empty text.
 
358
        """
 
359
        mutter('storing file {%s} in revision {%s}',
 
360
               self.file_id, self.revision)
 
361
        self._add_text_to_weave([], file_parents, weave_store, transaction)
 
362
 
183
363
    def __eq__(self, other):
184
364
        if not isinstance(other, InventoryEntry):
185
365
            return NotImplemented
186
366
 
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
 
 
 
367
        return ((self.file_id == other.file_id)
 
368
                and (self.name == other.name)
 
369
                and (other.symlink_target == self.symlink_target)
 
370
                and (self.text_sha1 == other.text_sha1)
 
371
                and (self.text_size == other.text_size)
 
372
                and (self.text_id == other.text_id)
 
373
                and (self.parent_id == other.parent_id)
 
374
                and (self.kind == other.kind)
 
375
                and (self.revision == other.revision)
 
376
                and (self.executable == other.executable)
 
377
                )
197
378
 
198
379
    def __ne__(self, other):
199
380
        return not (self == other)
201
382
    def __hash__(self):
202
383
        raise ValueError('not hashable')
203
384
 
 
385
    def _unchanged(self, previous_ie):
 
386
        """Has this entry changed relative to previous_ie.
 
387
 
 
388
        This method should be overriden in child classes.
 
389
        """
 
390
        compatible = True
 
391
        # different inv parent
 
392
        if previous_ie.parent_id != self.parent_id:
 
393
            compatible = False
 
394
        # renamed
 
395
        elif previous_ie.name != self.name:
 
396
            compatible = False
 
397
        return compatible
 
398
 
 
399
    def _read_tree_state(self, path, work_tree):
 
400
        """Populate fields in the inventory entry from the given tree.
 
401
        
 
402
        Note that this should be modified to be a noop on virtual trees
 
403
        as all entries created there are prepopulated.
 
404
        """
 
405
        # TODO: Rather than running this manually, we should check the 
 
406
        # working sha1 and other expensive properties when they're
 
407
        # first requested, or preload them if they're already known
 
408
        pass            # nothing to do by default
204
409
 
205
410
 
206
411
class RootEntry(InventoryEntry):
 
412
 
 
413
    def _check(self, checker, rev_id, tree):
 
414
        """See InventoryEntry._check"""
 
415
 
207
416
    def __init__(self, file_id):
208
417
        self.file_id = file_id
209
418
        self.children = {}
210
419
        self.kind = 'root_directory'
211
420
        self.parent_id = None
212
 
        self.name = ''
 
421
        self.name = u''
213
422
 
214
423
    def __eq__(self, other):
215
424
        if not isinstance(other, RootEntry):
219
428
               and (self.children == other.children)
220
429
 
221
430
 
 
431
class InventoryDirectory(InventoryEntry):
 
432
    """A directory in an inventory."""
 
433
 
 
434
    def _check(self, checker, rev_id, tree):
 
435
        """See InventoryEntry._check"""
 
436
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
 
437
            raise BzrCheckError('directory {%s} has text in revision {%s}'
 
438
                                % (self.file_id, rev_id))
 
439
 
 
440
    def copy(self):
 
441
        other = InventoryDirectory(self.file_id, self.name, self.parent_id)
 
442
        other.revision = self.revision
 
443
        # note that children are *not* copied; they're pulled across when
 
444
        # others are added
 
445
        return other
 
446
 
 
447
    def __init__(self, file_id, name, parent_id):
 
448
        super(InventoryDirectory, self).__init__(file_id, name, parent_id)
 
449
        self.children = {}
 
450
        self.kind = 'directory'
 
451
 
 
452
    def kind_character(self):
 
453
        """See InventoryEntry.kind_character."""
 
454
        return '/'
 
455
 
 
456
    def _put_in_tar(self, item, tree):
 
457
        """See InventoryEntry._put_in_tar."""
 
458
        item.type = tarfile.DIRTYPE
 
459
        fileobj = None
 
460
        item.name += '/'
 
461
        item.size = 0
 
462
        item.mode = 0755
 
463
        return fileobj
 
464
 
 
465
    def _put_on_disk(self, fullpath, tree):
 
466
        """See InventoryEntry._put_on_disk."""
 
467
        os.mkdir(fullpath)
 
468
 
 
469
 
 
470
class InventoryFile(InventoryEntry):
 
471
    """A file in an inventory."""
 
472
 
 
473
    def _check(self, checker, rev_id, tree):
 
474
        """See InventoryEntry._check"""
 
475
        revision = self.revision
 
476
        t = (self.file_id, revision)
 
477
        if t in checker.checked_texts:
 
478
            prev_sha = checker.checked_texts[t] 
 
479
            if prev_sha != self.text_sha1:
 
480
                raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
 
481
                                    (self.file_id, rev_id))
 
482
            else:
 
483
                checker.repeated_text_cnt += 1
 
484
                return
 
485
 
 
486
        if self.file_id not in checker.checked_weaves:
 
487
            mutter('check weave {%s}', self.file_id)
 
488
            w = tree.get_weave(self.file_id)
 
489
            # Not passing a progress bar, because it creates a new
 
490
            # progress, which overwrites the current progress,
 
491
            # and doesn't look nice
 
492
            w.check()
 
493
            checker.checked_weaves[self.file_id] = True
 
494
        else:
 
495
            w = tree.get_weave_prelude(self.file_id)
 
496
 
 
497
        mutter('check version {%s} of {%s}', rev_id, self.file_id)
 
498
        checker.checked_text_cnt += 1 
 
499
        # We can't check the length, because Weave doesn't store that
 
500
        # information, and the whole point of looking at the weave's
 
501
        # sha1sum is that we don't have to extract the text.
 
502
        if self.text_sha1 != w.get_sha1(self.revision):
 
503
            raise BzrCheckError('text {%s} version {%s} wrong sha1' 
 
504
                                % (self.file_id, self.revision))
 
505
        checker.checked_texts[t] = self.text_sha1
 
506
 
 
507
    def copy(self):
 
508
        other = InventoryFile(self.file_id, self.name, self.parent_id)
 
509
        other.executable = self.executable
 
510
        other.text_id = self.text_id
 
511
        other.text_sha1 = self.text_sha1
 
512
        other.text_size = self.text_size
 
513
        other.revision = self.revision
 
514
        return other
 
515
 
 
516
    def detect_changes(self, old_entry):
 
517
        """See InventoryEntry.detect_changes."""
 
518
        assert self.text_sha1 != None
 
519
        assert old_entry.text_sha1 != None
 
520
        text_modified = (self.text_sha1 != old_entry.text_sha1)
 
521
        meta_modified = (self.executable != old_entry.executable)
 
522
        return text_modified, meta_modified
 
523
 
 
524
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
525
             output_to, reverse=False):
 
526
        """See InventoryEntry._diff."""
 
527
        from_text = tree.get_file(self.file_id).readlines()
 
528
        if to_entry:
 
529
            to_text = to_tree.get_file(to_entry.file_id).readlines()
 
530
        else:
 
531
            to_text = []
 
532
        if not reverse:
 
533
            text_diff(from_label, from_text,
 
534
                      to_label, to_text, output_to)
 
535
        else:
 
536
            text_diff(to_label, to_text,
 
537
                      from_label, from_text, output_to)
 
538
 
 
539
    def has_text(self):
 
540
        """See InventoryEntry.has_text."""
 
541
        return True
 
542
 
 
543
    def __init__(self, file_id, name, parent_id):
 
544
        super(InventoryFile, self).__init__(file_id, name, parent_id)
 
545
        self.kind = 'file'
 
546
 
 
547
    def kind_character(self):
 
548
        """See InventoryEntry.kind_character."""
 
549
        return ''
 
550
 
 
551
    def _put_in_tar(self, item, tree):
 
552
        """See InventoryEntry._put_in_tar."""
 
553
        item.type = tarfile.REGTYPE
 
554
        fileobj = tree.get_file(self.file_id)
 
555
        item.size = self.text_size
 
556
        if tree.is_executable(self.file_id):
 
557
            item.mode = 0755
 
558
        else:
 
559
            item.mode = 0644
 
560
        return fileobj
 
561
 
 
562
    def _put_on_disk(self, fullpath, tree):
 
563
        """See InventoryEntry._put_on_disk."""
 
564
        pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
 
565
        if tree.is_executable(self.file_id):
 
566
            os.chmod(fullpath, 0755)
 
567
 
 
568
    def _read_tree_state(self, path, work_tree):
 
569
        """See InventoryEntry._read_tree_state."""
 
570
        self.text_sha1 = work_tree.get_file_sha1(self.file_id)
 
571
        self.executable = work_tree.is_executable(self.file_id)
 
572
 
 
573
    def _snapshot_text(self, file_parents, work_tree, weave_store, transaction):
 
574
        """See InventoryEntry._snapshot_text."""
 
575
        mutter('storing file {%s} in revision {%s}',
 
576
               self.file_id, self.revision)
 
577
        # special case to avoid diffing on renames or 
 
578
        # reparenting
 
579
        if (len(file_parents) == 1
 
580
            and self.text_sha1 == file_parents.values()[0].text_sha1
 
581
            and self.text_size == file_parents.values()[0].text_size):
 
582
            previous_ie = file_parents.values()[0]
 
583
            weave_store.add_identical_text(
 
584
                self.file_id, previous_ie.revision, 
 
585
                self.revision, file_parents, transaction)
 
586
        else:
 
587
            new_lines = work_tree.get_file(self.file_id).readlines()
 
588
            self._add_text_to_weave(new_lines, file_parents, weave_store,
 
589
                                    transaction)
 
590
            self.text_sha1 = sha_strings(new_lines)
 
591
            self.text_size = sum(map(len, new_lines))
 
592
 
 
593
 
 
594
    def _unchanged(self, previous_ie):
 
595
        """See InventoryEntry._unchanged."""
 
596
        compatible = super(InventoryFile, self)._unchanged(previous_ie)
 
597
        if self.text_sha1 != previous_ie.text_sha1:
 
598
            compatible = False
 
599
        else:
 
600
            # FIXME: 20050930 probe for the text size when getting sha1
 
601
            # in _read_tree_state
 
602
            self.text_size = previous_ie.text_size
 
603
        if self.executable != previous_ie.executable:
 
604
            compatible = False
 
605
        return compatible
 
606
 
 
607
 
 
608
class InventoryLink(InventoryEntry):
 
609
    """A file in an inventory."""
 
610
 
 
611
    __slots__ = ['symlink_target']
 
612
 
 
613
    def _check(self, checker, rev_id, tree):
 
614
        """See InventoryEntry._check"""
 
615
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
 
616
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
 
617
                    % (self.file_id, rev_id))
 
618
        if self.symlink_target == None:
 
619
            raise BzrCheckError('symlink {%s} has no target in revision {%s}'
 
620
                    % (self.file_id, rev_id))
 
621
 
 
622
    def copy(self):
 
623
        other = InventoryLink(self.file_id, self.name, self.parent_id)
 
624
        other.symlink_target = self.symlink_target
 
625
        other.revision = self.revision
 
626
        return other
 
627
 
 
628
    def detect_changes(self, old_entry):
 
629
        """See InventoryEntry.detect_changes."""
 
630
        # FIXME: which _modified field should we use ? RBC 20051003
 
631
        text_modified = (self.symlink_target != old_entry.symlink_target)
 
632
        if text_modified:
 
633
            mutter("    symlink target changed")
 
634
        meta_modified = False
 
635
        return text_modified, meta_modified
 
636
 
 
637
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
638
             output_to, reverse=False):
 
639
        """See InventoryEntry._diff."""
 
640
        from_text = self.symlink_target
 
641
        if to_entry is not None:
 
642
            to_text = to_entry.symlink_target
 
643
            if reverse:
 
644
                temp = from_text
 
645
                from_text = to_text
 
646
                to_text = temp
 
647
            print >>output_to, '=== target changed %r => %r' % (from_text, to_text)
 
648
        else:
 
649
            if not reverse:
 
650
                print >>output_to, '=== target was %r' % self.symlink_target
 
651
            else:
 
652
                print >>output_to, '=== target is %r' % self.symlink_target
 
653
 
 
654
    def __init__(self, file_id, name, parent_id):
 
655
        super(InventoryLink, self).__init__(file_id, name, parent_id)
 
656
        self.kind = 'symlink'
 
657
 
 
658
    def kind_character(self):
 
659
        """See InventoryEntry.kind_character."""
 
660
        return ''
 
661
 
 
662
    def _put_in_tar(self, item, tree):
 
663
        """See InventoryEntry._put_in_tar."""
 
664
        item.type = tarfile.SYMTYPE
 
665
        fileobj = None
 
666
        item.size = 0
 
667
        item.mode = 0755
 
668
        item.linkname = self.symlink_target
 
669
        return fileobj
 
670
 
 
671
    def _put_on_disk(self, fullpath, tree):
 
672
        """See InventoryEntry._put_on_disk."""
 
673
        try:
 
674
            os.symlink(self.symlink_target, fullpath)
 
675
        except OSError,e:
 
676
            raise BzrError("Failed to create symlink %r -> %r, error: %s" % (fullpath, self.symlink_target, e))
 
677
 
 
678
    def _read_tree_state(self, path, work_tree):
 
679
        """See InventoryEntry._read_tree_state."""
 
680
        self.symlink_target = work_tree.get_symlink_target(self.file_id)
 
681
 
 
682
    def _unchanged(self, previous_ie):
 
683
        """See InventoryEntry._unchanged."""
 
684
        compatible = super(InventoryLink, self)._unchanged(previous_ie)
 
685
        if self.symlink_target != previous_ie.symlink_target:
 
686
            compatible = False
 
687
        return compatible
 
688
 
222
689
 
223
690
class Inventory(object):
224
691
    """Inventory of versioned files in a tree.
238
705
    inserted, other than through the Inventory API.
239
706
 
240
707
    >>> 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')
 
708
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
 
709
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
243
710
    >>> inv['123-123'].name
244
711
    'hello.c'
245
712
 
255
722
    >>> [x[0] for x in inv.iter_entries()]
256
723
    ['hello.c']
257
724
    >>> 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')
 
725
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
 
726
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
260
727
    """
261
728
    def __init__(self, root_id=ROOT_ID):
262
729
        """Create or read an inventory.
268
735
        The inventory is created with a default root directory, with
269
736
        an id of None.
270
737
        """
271
 
        # We are letting Branch(init=True) create a unique inventory
 
738
        # We are letting Branch.initialize() create a unique inventory
272
739
        # root id. Rather than generating a random one here.
273
740
        #if root_id is None:
274
741
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
310
777
            yield name, ie
311
778
            if ie.kind == 'directory':
312
779
                for cn, cie in self.iter_entries(from_dir=ie.file_id):
313
 
                    yield os.path.join(name, cn), cie
 
780
                    yield pathjoin(name, cn), cie
314
781
 
315
782
 
316
783
    def entries(self):
323
790
            kids = dir_ie.children.items()
324
791
            kids.sort()
325
792
            for name, ie in kids:
326
 
                child_path = os.path.join(dir_path, name)
 
793
                child_path = pathjoin(dir_path, name)
327
794
                accum.append((child_path, ie))
328
795
                if ie.kind == 'directory':
329
796
                    descend(ie, child_path)
330
797
 
331
 
        descend(self.root, '')
 
798
        descend(self.root, u'')
332
799
        return accum
333
800
 
334
801
 
343
810
            kids.sort()
344
811
 
345
812
            for name, child_ie in kids:
346
 
                child_path = os.path.join(parent_path, name)
 
813
                child_path = pathjoin(parent_path, name)
347
814
                descend(child_ie, child_path)
348
 
        descend(self.root, '')
 
815
        descend(self.root, u'')
349
816
        return accum
350
817
        
351
818
 
354
821
        """True if this entry contains a file with given id.
355
822
 
356
823
        >>> inv = Inventory()
357
 
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
358
 
        InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
 
824
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
 
825
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
359
826
        >>> '123' in inv
360
827
        True
361
828
        >>> '456' in inv
368
835
        """Return the entry for given file_id.
369
836
 
370
837
        >>> inv = Inventory()
371
 
        >>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
372
 
        InventoryEntry('123123', 'hello.c', kind='file', parent_id='TREE_ROOT')
 
838
        >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
 
839
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
373
840
        >>> inv['123123'].name
374
841
        'hello.c'
375
842
        """
410
877
 
411
878
        if parent.children.has_key(entry.name):
412
879
            raise BzrError("%s is already versioned" %
413
 
                    appendpath(self.id2path(parent.file_id), entry.name))
 
880
                    pathjoin(self.id2path(parent.file_id), entry.name))
414
881
 
415
882
        self._byid[entry.file_id] = entry
416
883
        parent.children[entry.name] = entry
423
890
        The immediate parent must already be versioned.
424
891
 
425
892
        Returns the new entry object."""
426
 
        from bzrlib.branch import gen_file_id
 
893
        from bzrlib.workingtree import gen_file_id
427
894
        
428
895
        parts = bzrlib.osutils.splitpath(relpath)
429
896
        if len(parts) == 0:
435
902
        parent_path = parts[:-1]
436
903
        parent_id = self.path2id(parent_path)
437
904
        if parent_id == None:
438
 
            raise NotVersionedError(parent_path)
439
 
 
440
 
        ie = InventoryEntry(file_id, parts[-1],
441
 
                            kind=kind, parent_id=parent_id)
 
905
            raise NotVersionedError(path=parent_path)
 
906
        if kind == 'directory':
 
907
            ie = InventoryDirectory(file_id, parts[-1], parent_id)
 
908
        elif kind == 'file':
 
909
            ie = InventoryFile(file_id, parts[-1], parent_id)
 
910
        elif kind == 'symlink':
 
911
            ie = InventoryLink(file_id, parts[-1], parent_id)
 
912
        else:
 
913
            raise BzrError("unknown kind %r" % kind)
442
914
        return self.add(ie)
443
915
 
444
916
 
446
918
        """Remove entry by id.
447
919
 
448
920
        >>> inv = Inventory()
449
 
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
450
 
        InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
 
921
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
 
922
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
451
923
        >>> '123' in inv
452
924
        True
453
925
        >>> del inv['123']
476
948
        >>> i2 = Inventory()
477
949
        >>> i1 == i2
478
950
        True
479
 
        >>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
480
 
        InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
 
951
        >>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
 
952
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
481
953
        >>> i1 == i2
482
954
        False
483
 
        >>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
484
 
        InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
 
955
        >>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
 
956
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
485
957
        >>> i1 == i2
486
958
        True
487
959
        """
496
968
 
497
969
 
498
970
    def __ne__(self, other):
499
 
        return not (self == other)
 
971
        return not self.__eq__(other)
500
972
 
501
973
 
502
974
    def __hash__(self):
523
995
 
524
996
 
525
997
    def id2path(self, file_id):
526
 
        """Return as a list the path to file_id."""
527
 
 
 
998
        """Return as a list the path to file_id.
 
999
        
 
1000
        >>> i = Inventory()
 
1001
        >>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))
 
1002
        >>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))
 
1003
        >>> print i.id2path('foo-id')
 
1004
        src/foo.c
 
1005
        """
528
1006
        # get all names, skipping root
529
1007
        p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
530
 
        return os.sep.join(p)
 
1008
        if p:
 
1009
            return pathjoin(*p)
 
1010
        else:
 
1011
            return ''
531
1012
            
532
1013
 
533
1014