← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: John Arbash Meinel
  • Date: 2006-05-27 01:54:40 UTC
  • mto: (1711.2.26 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1734.
  • Revision ID: john@arbash-meinel.com-20060527015440-1a10495d8e56ed5f
deprecating appendpath, it does exactly what pathjoin does

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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
27
27
# created, but it's not for now.
28
28
ROOT_ID = "TREE_ROOT"
29
29
 
30
 
import os
 
30
 
 
31
import os.path
31
32
import re
32
33
import sys
33
 
 
34
 
from bzrlib.lazy_import import lazy_import
35
 
lazy_import(globals(), """
36
 
import collections
37
34
import tarfile
 
35
import types
38
36
 
39
37
import bzrlib
40
 
from bzrlib import (
41
 
    errors,
42
 
    generate_ids,
43
 
    osutils,
44
 
    symbol_versioning,
45
 
    workingtree,
46
 
    )
47
 
""")
48
 
 
49
 
from bzrlib.errors import (
50
 
    BzrCheckError,
51
 
    BzrError,
52
 
    )
53
 
from bzrlib.symbol_versioning import deprecated_in, deprecated_method
 
38
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
 
39
                            pathjoin, sha_strings)
 
40
from bzrlib.errors import (NotVersionedError, InvalidEntryName,
 
41
                           BzrError, BzrCheckError, BinaryFile)
54
42
from bzrlib.trace import mutter
55
43
 
56
44
 
88
76
    >>> i.path2id('')
89
77
    'TREE_ROOT'
90
78
    >>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
91
 
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
 
79
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT')
92
80
    >>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
93
 
    InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None)
94
 
    >>> shouldbe = {0: '', 1: 'src', 2: 'src/hello.c'}
 
81
    InventoryFile('2323', 'hello.c', parent_id='123')
 
82
    >>> shouldbe = {0: 'src', 1: pathjoin('src','hello.c')}
95
83
    >>> for ix, j in enumerate(i.iter_entries()):
96
84
    ...   print (j[0] == shouldbe[ix], j[1])
97
85
    ... 
98
 
    (True, InventoryDirectory('TREE_ROOT', u'', parent_id=None, revision=None))
99
 
    (True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None))
100
 
    (True, InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None))
 
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'))
 
89
    Traceback (most recent call last):
 
90
    ...
 
91
    BzrError: inventory already contains entry with id {2323}
101
92
    >>> i.add(InventoryFile('2324', 'bye.c', '123'))
102
 
    InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None)
 
93
    InventoryFile('2324', 'bye.c', parent_id='123')
103
94
    >>> i.add(InventoryDirectory('2325', 'wibble', '123'))
104
 
    InventoryDirectory('2325', 'wibble', parent_id='123', revision=None)
 
95
    InventoryDirectory('2325', 'wibble', parent_id='123')
105
96
    >>> i.path2id('src/wibble')
106
97
    '2325'
107
98
    >>> '2325' in i
108
99
    True
109
100
    >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
110
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
 
101
    InventoryFile('2326', 'wibble.c', parent_id='2325')
111
102
    >>> i['2326']
112
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
 
103
    InventoryFile('2326', 'wibble.c', parent_id='2325')
113
104
    >>> for path, entry in i.iter_entries():
114
105
    ...     print path
 
106
    ...     assert i.path2id(path)
115
107
    ... 
116
 
    <BLANKLINE>
117
108
    src
118
109
    src/bye.c
119
110
    src/hello.c
131
122
    RENAMED = 'renamed'
132
123
    MODIFIED_AND_RENAMED = 'modified and renamed'
133
124
    
134
 
    __slots__ = []
 
125
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
 
126
                 'text_id', 'parent_id', 'children', 'executable', 
 
127
                 'revision']
 
128
 
 
129
    def _add_text_to_weave(self, new_lines, parents, weave_store, transaction):
 
130
        versionedfile = weave_store.get_weave_or_empty(self.file_id,
 
131
                                                       transaction)
 
132
        versionedfile.add_lines(self.revision, parents, new_lines)
 
133
        versionedfile.clear_cache()
135
134
 
136
135
    def detect_changes(self, old_entry):
137
136
        """Return a (text_modified, meta_modified) from this to old_entry.
141
140
        """
142
141
        return False, False
143
142
 
 
143
    def diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
144
             output_to, reverse=False):
 
145
        """Perform a diff from this to to_entry.
 
146
 
 
147
        text_diff will be used for textual difference calculation.
 
148
        This is a template method, override _diff in child classes.
 
149
        """
 
150
        self._read_tree_state(tree.id2path(self.file_id), tree)
 
151
        if to_entry:
 
152
            # cannot diff from one kind to another - you must do a removal
 
153
            # and an addif they do not match.
 
154
            assert self.kind == to_entry.kind
 
155
            to_entry._read_tree_state(to_tree.id2path(to_entry.file_id),
 
156
                                      to_tree)
 
157
        self._diff(text_diff, from_label, tree, to_label, to_entry, to_tree,
 
158
                   output_to, reverse)
 
159
 
144
160
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
145
161
             output_to, reverse=False):
146
162
        """Perform a diff between two entries of the same kind."""
147
 
    
148
 
    def parent_candidates(self, previous_inventories):
149
 
        """Find possible per-file graph parents.
150
 
 
151
 
        This is currently defined by:
152
 
         - Select the last changed revision in the parent inventory.
153
 
         - Do deal with a short lived bug in bzr 0.8's development two entries
154
 
           that have the same last changed but different 'x' bit settings are
155
 
           changed in-place.
 
163
 
 
164
    def find_previous_heads(self, previous_inventories,
 
165
                            versioned_file_store,
 
166
                            transaction,
 
167
                            entry_vf=None):
 
168
        """Return the revisions and entries that directly preceed this.
 
169
 
 
170
        Returned as a map from revision to inventory entry.
 
171
 
 
172
        This is a map containing the file revisions in all parents
 
173
        for which the file exists, and its revision is not a parent of
 
174
        any other. If the file is new, the set will be empty.
 
175
 
 
176
        :param versioned_file_store: A store where ancestry data on this
 
177
                                     file id can be queried.
 
178
        :param transaction: The transaction that queries to the versioned 
 
179
                            file store should be completed under.
 
180
        :param entry_vf: The entry versioned file, if its already available.
156
181
        """
 
182
        def get_ancestors(weave, entry):
 
183
            return set(weave.get_ancestry(entry.revision))
157
184
        # revision:ie mapping for each ie found in previous_inventories.
158
185
        candidates = {}
 
186
        # revision:ie mapping with one revision for each head.
 
187
        heads = {}
 
188
        # revision: ancestor list for each head
 
189
        head_ancestors = {}
159
190
        # identify candidate head revision ids.
160
191
        for inv in previous_inventories:
161
192
            if self.file_id in inv:
162
193
                ie = inv[self.file_id]
 
194
                assert ie.file_id == self.file_id
163
195
                if ie.revision in candidates:
164
196
                    # same revision value in two different inventories:
165
197
                    # correct possible inconsistencies:
171
203
                            ie.executable = False
172
204
                    except AttributeError:
173
205
                        pass
 
206
                    # must now be the same.
 
207
                    assert candidates[ie.revision] == ie
174
208
                else:
175
209
                    # add this revision as a candidate.
176
210
                    candidates[ie.revision] = ie
177
 
        return candidates
178
 
 
179
 
    @deprecated_method(deprecated_in((1, 6, 0)))
 
211
 
 
212
        # common case optimisation
 
213
        if len(candidates) == 1:
 
214
            # if there is only one candidate revision found
 
215
            # then we can opening the versioned file to access ancestry:
 
216
            # there cannot be any ancestors to eliminate when there is 
 
217
            # only one revision available.
 
218
            heads[ie.revision] = ie
 
219
            return heads
 
220
 
 
221
        # eliminate ancestors amongst the available candidates:
 
222
        # heads are those that are not an ancestor of any other candidate
 
223
        # - this provides convergence at a per-file level.
 
224
        for ie in candidates.values():
 
225
            # may be an ancestor of a known head:
 
226
            already_present = 0 != len(
 
227
                [head for head in heads 
 
228
                 if ie.revision in head_ancestors[head]])
 
229
            if already_present:
 
230
                # an ancestor of an analyzed candidate.
 
231
                continue
 
232
            # not an ancestor of a known head:
 
233
            # load the versioned file for this file id if needed
 
234
            if entry_vf is None:
 
235
                entry_vf = versioned_file_store.get_weave_or_empty(
 
236
                    self.file_id, transaction)
 
237
            ancestors = get_ancestors(entry_vf, ie)
 
238
            # may knock something else out:
 
239
            check_heads = list(heads.keys())
 
240
            for head in check_heads:
 
241
                if head in ancestors:
 
242
                    # this previously discovered 'head' is not
 
243
                    # really a head - its an ancestor of the newly 
 
244
                    # found head,
 
245
                    heads.pop(head)
 
246
            head_ancestors[ie.revision] = ancestors
 
247
            heads[ie.revision] = ie
 
248
        return heads
 
249
 
180
250
    def get_tar_item(self, root, dp, now, tree):
181
251
        """Get a tarfile item and a file stream for its content."""
182
 
        item = tarfile.TarInfo(osutils.pathjoin(root, dp).encode('utf8'))
 
252
        item = tarfile.TarInfo(pathjoin(root, dp))
183
253
        # TODO: would be cool to actually set it to the timestamp of the
184
254
        # revision it was last changed
185
255
        item.mtime = now
212
282
        Traceback (most recent call last):
213
283
        InvalidEntryName: Invalid entry name: src/hello.c
214
284
        """
 
285
        assert isinstance(name, basestring), name
215
286
        if '/' in name or '\\' in name:
216
 
            raise errors.InvalidEntryName(name=name)
 
287
            raise InvalidEntryName(name=name)
217
288
        self.executable = False
218
289
        self.revision = None
219
290
        self.text_sha1 = None
223
294
        self.text_id = text_id
224
295
        self.parent_id = parent_id
225
296
        self.symlink_target = None
226
 
        self.reference_revision = None
227
297
 
228
298
    def kind_character(self):
229
299
        """Return a short kind indicator useful for appending to names."""
230
300
        raise BzrError('unknown kind %r' % self.kind)
231
301
 
232
 
    known_kinds = ('file', 'directory', 'symlink')
 
302
    known_kinds = ('file', 'directory', 'symlink', 'root_directory')
233
303
 
234
304
    def _put_in_tar(self, item, tree):
235
305
        """populate item for stashing in a tar, and return the content stream.
239
309
        raise BzrError("don't know how to export {%s} of kind %r" %
240
310
                       (self.file_id, self.kind))
241
311
 
242
 
    @deprecated_method(deprecated_in((1, 6, 0)))
243
312
    def put_on_disk(self, dest, dp, tree):
244
313
        """Create a representation of self on disk in the prefix dest.
245
314
        
246
315
        This is a template method - implement _put_on_disk in subclasses.
247
316
        """
248
 
        fullpath = osutils.pathjoin(dest, dp)
 
317
        fullpath = pathjoin(dest, dp)
249
318
        self._put_on_disk(fullpath, tree)
250
 
        # mutter("  export {%s} kind %s to %s", self.file_id,
251
 
        #         self.kind, fullpath)
 
319
        mutter("  export {%s} kind %s to %s", self.file_id,
 
320
                self.kind, fullpath)
252
321
 
253
322
    def _put_on_disk(self, fullpath, tree):
254
323
        """Put this entry onto disk at fullpath, from tree tree."""
255
324
        raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
256
325
 
257
326
    def sorted_children(self):
258
 
        return sorted(self.children.items())
 
327
        l = self.children.items()
 
328
        l.sort()
 
329
        return l
259
330
 
260
331
    @staticmethod
261
332
    def versionable_kind(kind):
262
 
        return (kind in ('file', 'directory', 'symlink', 'tree-reference'))
 
333
        return kind in ('file', 'directory', 'symlink')
263
334
 
264
335
    def check(self, checker, rev_id, inv, tree):
265
336
        """Check this inventory entry is intact.
275
346
        :param inv: Inventory from which the entry was loaded.
276
347
        :param tree: RevisionTree for this entry.
277
348
        """
278
 
        if self.parent_id is not None:
 
349
        if self.parent_id != None:
279
350
            if not inv.has_id(self.parent_id):
280
351
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
281
352
                        % (self.parent_id, rev_id))
310
381
            return 'added'
311
382
        elif new_entry is None:
312
383
            return 'removed'
313
 
        if old_entry.kind != new_entry.kind:
314
 
            return 'modified'
315
384
        text_modified, meta_modified = new_entry.detect_changes(old_entry)
316
385
        if text_modified or meta_modified:
317
386
            modified = True
333
402
        return 'unchanged'
334
403
 
335
404
    def __repr__(self):
336
 
        return ("%s(%r, %r, parent_id=%r, revision=%r)"
 
405
        return ("%s(%r, %r, parent_id=%r)"
337
406
                % (self.__class__.__name__,
338
407
                   self.file_id,
339
408
                   self.name,
340
 
                   self.parent_id,
341
 
                   self.revision))
 
409
                   self.parent_id))
 
410
 
 
411
    def snapshot(self, revision, path, previous_entries,
 
412
                 work_tree, weave_store, transaction):
 
413
        """Make a snapshot of this entry which may or may not have changed.
 
414
        
 
415
        This means that all its fields are populated, that it has its
 
416
        text stored in the text store or weave.
 
417
        """
 
418
        mutter('new parents of %s are %r', path, previous_entries)
 
419
        self._read_tree_state(path, work_tree)
 
420
        if len(previous_entries) == 1:
 
421
            # cannot be unchanged unless there is only one parent file rev.
 
422
            parent_ie = previous_entries.values()[0]
 
423
            if self._unchanged(parent_ie):
 
424
                mutter("found unchanged entry")
 
425
                self.revision = parent_ie.revision
 
426
                return "unchanged"
 
427
        return self._snapshot_into_revision(revision, previous_entries, 
 
428
                                            work_tree, weave_store, transaction)
 
429
 
 
430
    def _snapshot_into_revision(self, revision, previous_entries, work_tree,
 
431
                                weave_store, transaction):
 
432
        """Record this revision unconditionally into a store.
 
433
 
 
434
        The entry's last-changed revision property (`revision`) is updated to 
 
435
        that of the new revision.
 
436
        
 
437
        :param revision: id of the new revision that is being recorded.
 
438
 
 
439
        :returns: String description of the commit (e.g. "merged", "modified"), etc.
 
440
        """
 
441
        mutter('new revision {%s} for {%s}', revision, self.file_id)
 
442
        self.revision = revision
 
443
        self._snapshot_text(previous_entries, work_tree, weave_store,
 
444
                            transaction)
 
445
 
 
446
    def _snapshot_text(self, file_parents, work_tree, weave_store, transaction): 
 
447
        """Record the 'text' of this entry, whatever form that takes.
 
448
        
 
449
        This default implementation simply adds an empty text.
 
450
        """
 
451
        mutter('storing file {%s} in revision {%s}',
 
452
               self.file_id, self.revision)
 
453
        self._add_text_to_weave([], file_parents.keys(), weave_store, transaction)
342
454
 
343
455
    def __eq__(self, other):
344
456
        if not isinstance(other, InventoryEntry):
354
466
                and (self.kind == other.kind)
355
467
                and (self.revision == other.revision)
356
468
                and (self.executable == other.executable)
357
 
                and (self.reference_revision == other.reference_revision)
358
469
                )
359
470
 
360
471
    def __ne__(self, other):
366
477
    def _unchanged(self, previous_ie):
367
478
        """Has this entry changed relative to previous_ie.
368
479
 
369
 
        This method should be overridden in child classes.
 
480
        This method should be overriden in child classes.
370
481
        """
371
482
        compatible = True
372
483
        # different inv parent
375
486
        # renamed
376
487
        elif previous_ie.name != self.name:
377
488
            compatible = False
378
 
        elif previous_ie.kind != self.kind:
379
 
            compatible = False
380
489
        return compatible
381
490
 
382
491
    def _read_tree_state(self, path, work_tree):
396
505
 
397
506
class RootEntry(InventoryEntry):
398
507
 
399
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
400
 
                 'text_id', 'parent_id', 'children', 'executable',
401
 
                 'revision', 'symlink_target', 'reference_revision']
402
 
 
403
508
    def _check(self, checker, rev_id, tree):
404
509
        """See InventoryEntry._check"""
405
510
 
406
511
    def __init__(self, file_id):
407
512
        self.file_id = file_id
408
513
        self.children = {}
409
 
        self.kind = 'directory'
 
514
        self.kind = 'root_directory'
410
515
        self.parent_id = None
411
516
        self.name = u''
412
 
        self.revision = None
413
 
        symbol_versioning.warn('RootEntry is deprecated as of bzr 0.10.'
414
 
                               '  Please use InventoryDirectory instead.',
415
 
                               DeprecationWarning, stacklevel=2)
416
517
 
417
518
    def __eq__(self, other):
418
519
        if not isinstance(other, RootEntry):
425
526
class InventoryDirectory(InventoryEntry):
426
527
    """A directory in an inventory."""
427
528
 
428
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
429
 
                 'text_id', 'parent_id', 'children', 'executable',
430
 
                 'revision', 'symlink_target', 'reference_revision']
431
 
 
432
529
    def _check(self, checker, rev_id, tree):
433
530
        """See InventoryEntry._check"""
434
 
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
 
531
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
435
532
            raise BzrCheckError('directory {%s} has text in revision {%s}'
436
533
                                % (self.file_id, rev_id))
437
534
 
468
565
class InventoryFile(InventoryEntry):
469
566
    """A file in an inventory."""
470
567
 
471
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
472
 
                 'text_id', 'parent_id', 'children', 'executable',
473
 
                 'revision', 'symlink_target', 'reference_revision']
474
 
 
475
568
    def _check(self, checker, tree_revision_id, tree):
476
569
        """See InventoryEntry._check"""
477
 
        key = (self.file_id, self.revision)
478
 
        if key in checker.checked_texts:
479
 
            prev_sha = checker.checked_texts[key]
 
570
        t = (self.file_id, self.revision)
 
571
        if t in checker.checked_texts:
 
572
            prev_sha = checker.checked_texts[t]
480
573
            if prev_sha != self.text_sha1:
481
 
                raise BzrCheckError(
482
 
                    'mismatched sha1 on {%s} in {%s} (%s != %s) %r' %
483
 
                    (self.file_id, tree_revision_id, prev_sha, self.text_sha1,
484
 
                     t))
 
574
                raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
 
575
                                    (self.file_id, tree_revision_id))
485
576
            else:
486
577
                checker.repeated_text_cnt += 1
487
578
                return
488
579
 
 
580
        if self.file_id not in checker.checked_weaves:
 
581
            mutter('check weave {%s}', self.file_id)
 
582
            w = tree.get_weave(self.file_id)
 
583
            # Not passing a progress bar, because it creates a new
 
584
            # progress, which overwrites the current progress,
 
585
            # and doesn't look nice
 
586
            w.check()
 
587
            checker.checked_weaves[self.file_id] = True
 
588
        else:
 
589
            w = tree.get_weave(self.file_id)
 
590
 
489
591
        mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)
490
592
        checker.checked_text_cnt += 1
491
593
        # We can't check the length, because Weave doesn't store that
492
594
        # information, and the whole point of looking at the weave's
493
595
        # sha1sum is that we don't have to extract the text.
494
 
        if (self.text_sha1 != tree._repository.texts.get_sha1s([key])[key]):
495
 
            raise BzrCheckError('text {%s} version {%s} wrong sha1' % key)
496
 
        checker.checked_texts[key] = self.text_sha1
 
596
        if self.text_sha1 != w.get_sha1(self.revision):
 
597
            raise BzrCheckError('text {%s} version {%s} wrong sha1' 
 
598
                                % (self.file_id, self.revision))
 
599
        checker.checked_texts[t] = self.text_sha1
497
600
 
498
601
    def copy(self):
499
602
        other = InventoryFile(self.file_id, self.name, self.parent_id)
506
609
 
507
610
    def detect_changes(self, old_entry):
508
611
        """See InventoryEntry.detect_changes."""
 
612
        assert self.text_sha1 != None
 
613
        assert old_entry.text_sha1 != None
509
614
        text_modified = (self.text_sha1 != old_entry.text_sha1)
510
615
        meta_modified = (self.executable != old_entry.executable)
511
616
        return text_modified, meta_modified
513
618
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
514
619
             output_to, reverse=False):
515
620
        """See InventoryEntry._diff."""
516
 
        from bzrlib.diff import DiffText
517
 
        from_file_id = self.file_id
518
 
        if to_entry:
519
 
            to_file_id = to_entry.file_id
520
 
        else:
521
 
            to_file_id = None
522
 
        if reverse:
523
 
            to_file_id, from_file_id = from_file_id, to_file_id
524
 
            tree, to_tree = to_tree, tree
525
 
            from_label, to_label = to_label, from_label
526
 
        differ = DiffText(tree, to_tree, output_to, 'utf-8', '', '',
527
 
                          text_diff)
528
 
        return differ.diff_text(from_file_id, to_file_id, from_label, to_label)
 
621
        try:
 
622
            from_text = tree.get_file(self.file_id).readlines()
 
623
            if to_entry:
 
624
                to_text = to_tree.get_file(to_entry.file_id).readlines()
 
625
            else:
 
626
                to_text = []
 
627
            if not reverse:
 
628
                text_diff(from_label, from_text,
 
629
                          to_label, to_text, output_to)
 
630
            else:
 
631
                text_diff(to_label, to_text,
 
632
                          from_label, from_text, output_to)
 
633
        except BinaryFile:
 
634
            if reverse:
 
635
                label_pair = (to_label, from_label)
 
636
            else:
 
637
                label_pair = (from_label, to_label)
 
638
            print >> output_to, "Binary files %s and %s differ" % label_pair
529
639
 
530
640
    def has_text(self):
531
641
        """See InventoryEntry.has_text."""
552
662
 
553
663
    def _put_on_disk(self, fullpath, tree):
554
664
        """See InventoryEntry._put_on_disk."""
555
 
        osutils.pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
 
665
        pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
556
666
        if tree.is_executable(self.file_id):
557
667
            os.chmod(fullpath, 0755)
558
668
 
559
669
    def _read_tree_state(self, path, work_tree):
560
670
        """See InventoryEntry._read_tree_state."""
561
 
        self.text_sha1 = work_tree.get_file_sha1(self.file_id, path=path)
562
 
        # FIXME: 20050930 probe for the text size when getting sha1
563
 
        # in _read_tree_state
564
 
        self.executable = work_tree.is_executable(self.file_id, path=path)
565
 
 
566
 
    def __repr__(self):
567
 
        return ("%s(%r, %r, parent_id=%r, sha1=%r, len=%s)"
568
 
                % (self.__class__.__name__,
569
 
                   self.file_id,
570
 
                   self.name,
571
 
                   self.parent_id,
572
 
                   self.text_sha1,
573
 
                   self.text_size))
 
671
        self.text_sha1 = work_tree.get_file_sha1(self.file_id)
 
672
        self.executable = work_tree.is_executable(self.file_id)
574
673
 
575
674
    def _forget_tree_state(self):
576
675
        self.text_sha1 = None
 
676
        self.executable = None
 
677
 
 
678
    def _snapshot_text(self, file_parents, work_tree, versionedfile_store, transaction):
 
679
        """See InventoryEntry._snapshot_text."""
 
680
        mutter('storing text of file {%s} in revision {%s} into %r',
 
681
               self.file_id, self.revision, versionedfile_store)
 
682
        # special case to avoid diffing on renames or 
 
683
        # reparenting
 
684
        if (len(file_parents) == 1
 
685
            and self.text_sha1 == file_parents.values()[0].text_sha1
 
686
            and self.text_size == file_parents.values()[0].text_size):
 
687
            previous_ie = file_parents.values()[0]
 
688
            versionedfile = versionedfile_store.get_weave(self.file_id, transaction)
 
689
            versionedfile.clone_text(self.revision, previous_ie.revision, file_parents.keys())
 
690
        else:
 
691
            new_lines = work_tree.get_file(self.file_id).readlines()
 
692
            self._add_text_to_weave(new_lines, file_parents.keys(), versionedfile_store,
 
693
                                    transaction)
 
694
            self.text_sha1 = sha_strings(new_lines)
 
695
            self.text_size = sum(map(len, new_lines))
 
696
 
577
697
 
578
698
    def _unchanged(self, previous_ie):
579
699
        """See InventoryEntry._unchanged."""
592
712
class InventoryLink(InventoryEntry):
593
713
    """A file in an inventory."""
594
714
 
595
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
596
 
                 'text_id', 'parent_id', 'children', 'executable',
597
 
                 'revision', 'symlink_target', 'reference_revision']
 
715
    __slots__ = ['symlink_target']
598
716
 
599
717
    def _check(self, checker, rev_id, tree):
600
718
        """See InventoryEntry._check"""
601
 
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
 
719
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
602
720
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
603
721
                    % (self.file_id, rev_id))
604
 
        if self.symlink_target is None:
 
722
        if self.symlink_target == None:
605
723
            raise BzrCheckError('symlink {%s} has no target in revision {%s}'
606
724
                    % (self.file_id, rev_id))
607
725
 
623
741
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
624
742
             output_to, reverse=False):
625
743
        """See InventoryEntry._diff."""
626
 
        from bzrlib.diff import DiffSymlink
627
 
        old_target = self.symlink_target
 
744
        from_text = self.symlink_target
628
745
        if to_entry is not None:
629
 
            new_target = to_entry.symlink_target
630
 
        else:
631
 
            new_target = None
632
 
        if not reverse:
633
 
            old_tree = tree
634
 
            new_tree = to_tree
635
 
        else:
636
 
            old_tree = to_tree
637
 
            new_tree = tree
638
 
            new_target, old_target = old_target, new_target
639
 
        differ = DiffSymlink(old_tree, new_tree, output_to)
640
 
        return differ.diff_symlink(old_target, new_target)
 
746
            to_text = to_entry.symlink_target
 
747
            if reverse:
 
748
                temp = from_text
 
749
                from_text = to_text
 
750
                to_text = temp
 
751
            print >>output_to, '=== target changed %r => %r' % (from_text, to_text)
 
752
        else:
 
753
            if not reverse:
 
754
                print >>output_to, '=== target was %r' % self.symlink_target
 
755
            else:
 
756
                print >>output_to, '=== target is %r' % self.symlink_target
641
757
 
642
758
    def __init__(self, file_id, name, parent_id):
643
759
        super(InventoryLink, self).__init__(file_id, name, parent_id)
678
794
        return compatible
679
795
 
680
796
 
681
 
class TreeReference(InventoryEntry):
682
 
    
683
 
    kind = 'tree-reference'
684
 
    
685
 
    def __init__(self, file_id, name, parent_id, revision=None,
686
 
                 reference_revision=None):
687
 
        InventoryEntry.__init__(self, file_id, name, parent_id)
688
 
        self.revision = revision
689
 
        self.reference_revision = reference_revision
690
 
 
691
 
    def copy(self):
692
 
        return TreeReference(self.file_id, self.name, self.parent_id,
693
 
                             self.revision, self.reference_revision)
694
 
 
695
 
    def _read_tree_state(self, path, work_tree):
696
 
        """Populate fields in the inventory entry from the given tree.
697
 
        """
698
 
        self.reference_revision = work_tree.get_reference_revision(
699
 
            self.file_id, path)
700
 
 
701
 
    def _forget_tree_state(self):
702
 
        self.reference_revision = None 
703
 
 
704
 
    def _unchanged(self, previous_ie):
705
 
        """See InventoryEntry._unchanged."""
706
 
        compatible = super(TreeReference, self)._unchanged(previous_ie)
707
 
        if self.reference_revision != previous_ie.reference_revision:
708
 
            compatible = False
709
 
        return compatible
710
 
 
711
 
 
712
797
class Inventory(object):
713
798
    """Inventory of versioned files in a tree.
714
799
 
728
813
 
729
814
    >>> inv = Inventory()
730
815
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
731
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
816
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
732
817
    >>> inv['123-123'].name
733
818
    'hello.c'
734
819
 
742
827
    May also look up by name:
743
828
 
744
829
    >>> [x[0] for x in inv.iter_entries()]
745
 
    ['', u'hello.c']
 
830
    ['hello.c']
746
831
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
747
832
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
748
 
    Traceback (most recent call last):
749
 
    BzrError: parent_id {TREE_ROOT} not in inventory
750
 
    >>> inv.add(InventoryFile('123-123', 'hello.c', 'TREE_ROOT-12345678-12345678'))
751
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678', sha1=None, len=None)
 
833
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
752
834
    """
753
835
    def __init__(self, root_id=ROOT_ID, revision_id=None):
754
836
        """Create or read an inventory.
760
842
        The inventory is created with a default root directory, with
761
843
        an id of None.
762
844
        """
763
 
        if root_id is not None:
764
 
            self._set_root(InventoryDirectory(root_id, u'', None))
765
 
        else:
766
 
            self.root = None
767
 
            self._byid = {}
 
845
        # We are letting Branch.create() create a unique inventory
 
846
        # root id. Rather than generating a random one here.
 
847
        #if root_id is None:
 
848
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
 
849
        self.root = RootEntry(root_id)
768
850
        self.revision_id = revision_id
769
 
 
770
 
    def __repr__(self):
771
 
        return "<Inventory object at %x, contents=%r>" % (id(self), self._byid)
772
 
 
773
 
    def apply_delta(self, delta):
774
 
        """Apply a delta to this inventory.
775
 
 
776
 
        :param delta: A list of changes to apply. After all the changes are
777
 
            applied the final inventory must be internally consistent, but it
778
 
            is ok to supply changes which, if only half-applied would have an
779
 
            invalid result - such as supplying two changes which rename two
780
 
            files, 'A' and 'B' with each other : [('A', 'B', 'A-id', a_entry),
781
 
            ('B', 'A', 'B-id', b_entry)].
782
 
 
783
 
            Each change is a tuple, of the form (old_path, new_path, file_id,
784
 
            new_entry).
785
 
            
786
 
            When new_path is None, the change indicates the removal of an entry
787
 
            from the inventory and new_entry will be ignored (using None is
788
 
            appropriate). If new_path is not None, then new_entry must be an
789
 
            InventoryEntry instance, which will be incorporated into the
790
 
            inventory (and replace any existing entry with the same file id).
791
 
            
792
 
            When old_path is None, the change indicates the addition of
793
 
            a new entry to the inventory.
794
 
            
795
 
            When neither new_path nor old_path are None, the change is a
796
 
            modification to an entry, such as a rename, reparent, kind change
797
 
            etc. 
798
 
 
799
 
            The children attribute of new_entry is ignored. This is because
800
 
            this method preserves children automatically across alterations to
801
 
            the parent of the children, and cases where the parent id of a
802
 
            child is changing require the child to be passed in as a separate
803
 
            change regardless. E.g. in the recursive deletion of a directory -
804
 
            the directory's children must be included in the delta, or the
805
 
            final inventory will be invalid.
806
 
        """
807
 
        children = {}
808
 
        # Remove all affected items which were in the original inventory,
809
 
        # starting with the longest paths, thus ensuring parents are examined
810
 
        # after their children, which means that everything we examine has no
811
 
        # modified children remaining by the time we examine it.
812
 
        for old_path, file_id in sorted(((op, f) for op, np, f, e in delta
813
 
                                        if op is not None), reverse=True):
814
 
            if file_id not in self:
815
 
                # adds come later
816
 
                continue
817
 
            # Preserve unaltered children of file_id for later reinsertion.
818
 
            file_id_children = getattr(self[file_id], 'children', {})
819
 
            if len(file_id_children):
820
 
                children[file_id] = file_id_children
821
 
            # Remove file_id and the unaltered children. If file_id is not
822
 
            # being deleted it will be reinserted back later.
823
 
            self.remove_recursive_id(file_id)
824
 
        # Insert all affected which should be in the new inventory, reattaching
825
 
        # their children if they had any. This is done from shortest path to
826
 
        # longest, ensuring that items which were modified and whose parents in
827
 
        # the resulting inventory were also modified, are inserted after their
828
 
        # parents.
829
 
        for new_path, new_entry in sorted((np, e) for op, np, f, e in
830
 
                                          delta if np is not None):
831
 
            if new_entry.kind == 'directory':
832
 
                # Pop the child which to allow detection of children whose
833
 
                # parents were deleted and which were not reattached to a new
834
 
                # parent.
835
 
                new_entry.children = children.pop(new_entry.file_id, {})
836
 
            self.add(new_entry)
837
 
        if len(children):
838
 
            # Get the parent id that was deleted
839
 
            parent_id, children = children.popitem()
840
 
            raise errors.InconsistentDelta("<deleted>", parent_id,
841
 
                "The file id was deleted but its children were not deleted.")
842
 
 
843
 
    def _set_root(self, ie):
844
 
        self.root = ie
845
851
        self._byid = {self.root.file_id: self.root}
846
852
 
 
853
 
847
854
    def copy(self):
848
855
        # TODO: jam 20051218 Should copy also copy the revision_id?
849
 
        entries = self.iter_entries()
850
 
        if self.root is None:
851
 
            return Inventory(root_id=None)
852
 
        other = Inventory(entries.next()[1].file_id)
853
 
        other.root.revision = self.root.revision
 
856
        other = Inventory(self.root.file_id)
854
857
        # copy recursively so we know directories will be added before
855
858
        # their children.  There are more efficient ways than this...
856
 
        for path, entry in entries:
 
859
        for path, entry in self.iter_entries():
 
860
            if entry == self.root:
 
861
                continue
857
862
            other.add(entry.copy())
858
863
        return other
859
864
 
 
865
 
860
866
    def __iter__(self):
861
867
        return iter(self._byid)
862
868
 
 
869
 
863
870
    def __len__(self):
864
871
        """Returns number of entries."""
865
872
        return len(self._byid)
866
873
 
 
874
 
867
875
    def iter_entries(self, from_dir=None):
868
876
        """Return (path, entry) pairs, in order by name."""
869
 
        if from_dir is None:
870
 
            if self.root is None:
871
 
                return
872
 
            from_dir = self.root
873
 
            yield '', self.root
874
 
        elif isinstance(from_dir, basestring):
875
 
            from_dir = self._byid[from_dir]
876
 
            
877
 
        # unrolling the recursive called changed the time from
878
 
        # 440ms/663ms (inline/total) to 116ms/116ms
879
 
        children = from_dir.children.items()
880
 
        children.sort()
881
 
        children = collections.deque(children)
882
 
        stack = [(u'', children)]
883
 
        while stack:
884
 
            from_dir_relpath, children = stack[-1]
885
 
 
886
 
            while children:
887
 
                name, ie = children.popleft()
888
 
 
889
 
                # we know that from_dir_relpath never ends in a slash
890
 
                # and 'f' doesn't begin with one, we can do a string op, rather
891
 
                # than the checks of pathjoin(), though this means that all paths
892
 
                # start with a slash
893
 
                path = from_dir_relpath + '/' + name
894
 
 
895
 
                yield path[1:], ie
896
 
 
897
 
                if ie.kind != 'directory':
898
 
                    continue
899
 
 
900
 
                # But do this child first
901
 
                new_children = ie.children.items()
902
 
                new_children.sort()
903
 
                new_children = collections.deque(new_children)
904
 
                stack.append((path, new_children))
905
 
                # Break out of inner loop, so that we start outer loop with child
906
 
                break
907
 
            else:
908
 
                # if we finished all children, pop it off the stack
909
 
                stack.pop()
910
 
 
911
 
    def iter_entries_by_dir(self, from_dir=None, specific_file_ids=None,
912
 
        yield_parents=False):
913
 
        """Iterate over the entries in a directory first order.
914
 
 
915
 
        This returns all entries for a directory before returning
916
 
        the entries for children of a directory. This is not
917
 
        lexicographically sorted order, and is a hybrid between
918
 
        depth-first and breadth-first.
919
 
 
920
 
        :param yield_parents: If True, yield the parents from the root leading
921
 
            down to specific_file_ids that have been requested. This has no
922
 
            impact if specific_file_ids is None.
923
 
        :return: This yields (path, entry) pairs
924
 
        """
925
 
        if specific_file_ids and not isinstance(specific_file_ids, set):
926
 
            specific_file_ids = set(specific_file_ids)
927
 
        # TODO? Perhaps this should return the from_dir so that the root is
928
 
        # yielded? or maybe an option?
929
 
        if from_dir is None:
930
 
            if self.root is None:
931
 
                return
932
 
            # Optimize a common case
933
 
            if (not yield_parents and specific_file_ids is not None and
934
 
                len(specific_file_ids) == 1):
935
 
                file_id = list(specific_file_ids)[0]
936
 
                if file_id in self:
937
 
                    yield self.id2path(file_id), self[file_id]
938
 
                return 
939
 
            from_dir = self.root
940
 
            if (specific_file_ids is None or yield_parents or
941
 
                self.root.file_id in specific_file_ids):
942
 
                yield u'', self.root
943
 
        elif isinstance(from_dir, basestring):
944
 
            from_dir = self._byid[from_dir]
945
 
 
946
 
        if specific_file_ids is not None:
947
 
            # TODO: jam 20070302 This could really be done as a loop rather
948
 
            #       than a bunch of recursive calls.
949
 
            parents = set()
950
 
            byid = self._byid
951
 
            def add_ancestors(file_id):
952
 
                if file_id not in byid:
953
 
                    return
954
 
                parent_id = byid[file_id].parent_id
955
 
                if parent_id is None:
956
 
                    return
957
 
                if parent_id not in parents:
958
 
                    parents.add(parent_id)
959
 
                    add_ancestors(parent_id)
960
 
            for file_id in specific_file_ids:
961
 
                add_ancestors(file_id)
962
 
        else:
963
 
            parents = None
964
 
            
965
 
        stack = [(u'', from_dir)]
966
 
        while stack:
967
 
            cur_relpath, cur_dir = stack.pop()
968
 
 
969
 
            child_dirs = []
970
 
            for child_name, child_ie in sorted(cur_dir.children.iteritems()):
971
 
 
972
 
                child_relpath = cur_relpath + child_name
973
 
 
974
 
                if (specific_file_ids is None or 
975
 
                    child_ie.file_id in specific_file_ids or
976
 
                    (yield_parents and child_ie.file_id in parents)):
977
 
                    yield child_relpath, child_ie
978
 
 
979
 
                if child_ie.kind == 'directory':
980
 
                    if parents is None or child_ie.file_id in parents:
981
 
                        child_dirs.append((child_relpath+'/', child_ie))
982
 
            stack.extend(reversed(child_dirs))
983
 
 
984
 
    def make_entry(self, kind, name, parent_id, file_id=None):
985
 
        """Simple thunk to bzrlib.inventory.make_entry."""
986
 
        return make_entry(kind, name, parent_id, file_id)
 
877
        if from_dir == None:
 
878
            assert self.root
 
879
            from_dir = self.root
 
880
        elif isinstance(from_dir, basestring):
 
881
            from_dir = self._byid[from_dir]
 
882
            
 
883
        kids = from_dir.children.items()
 
884
        kids.sort()
 
885
        for name, ie in kids:
 
886
            yield name, ie
 
887
            if ie.kind == 'directory':
 
888
                for cn, cie in self.iter_entries(from_dir=ie.file_id):
 
889
                    yield pathjoin(name, cn), cie
 
890
 
987
891
 
988
892
    def entries(self):
989
893
        """Return list of (path, ie) for all entries except the root.
995
899
            kids = dir_ie.children.items()
996
900
            kids.sort()
997
901
            for name, ie in kids:
998
 
                child_path = osutils.pathjoin(dir_path, name)
 
902
                child_path = pathjoin(dir_path, name)
999
903
                accum.append((child_path, ie))
1000
904
                if ie.kind == 'directory':
1001
905
                    descend(ie, child_path)
1003
907
        descend(self.root, u'')
1004
908
        return accum
1005
909
 
 
910
 
1006
911
    def directories(self):
1007
912
        """Return (path, entry) pairs for all directories, including the root.
1008
913
        """
1014
919
            kids.sort()
1015
920
 
1016
921
            for name, child_ie in kids:
1017
 
                child_path = osutils.pathjoin(parent_path, name)
 
922
                child_path = pathjoin(parent_path, name)
1018
923
                descend(child_ie, child_path)
1019
924
        descend(self.root, u'')
1020
925
        return accum
1021
926
        
 
927
 
 
928
 
1022
929
    def __contains__(self, file_id):
1023
930
        """True if this entry contains a file with given id.
1024
931
 
1025
932
        >>> inv = Inventory()
1026
933
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1027
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
934
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
1028
935
        >>> '123' in inv
1029
936
        True
1030
937
        >>> '456' in inv
1031
938
        False
1032
939
        """
1033
 
        return (file_id in self._byid)
 
940
        return file_id in self._byid
 
941
 
1034
942
 
1035
943
    def __getitem__(self, file_id):
1036
944
        """Return the entry for given file_id.
1037
945
 
1038
946
        >>> inv = Inventory()
1039
947
        >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
1040
 
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
948
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
1041
949
        >>> inv['123123'].name
1042
950
        'hello.c'
1043
951
        """
1044
952
        try:
1045
953
            return self._byid[file_id]
1046
954
        except KeyError:
1047
 
            # really we're passing an inventory, not a tree...
1048
 
            raise errors.NoSuchId(self, file_id)
 
955
            if file_id == None:
 
956
                raise BzrError("can't look up file_id None")
 
957
            else:
 
958
                raise BzrError("file_id {%s} not in inventory" % file_id)
 
959
 
1049
960
 
1050
961
    def get_file_kind(self, file_id):
1051
962
        return self._byid[file_id].kind
1053
964
    def get_child(self, parent_id, filename):
1054
965
        return self[parent_id].children.get(filename)
1055
966
 
1056
 
    def _add_child(self, entry):
1057
 
        """Add an entry to the inventory, without adding it to its parent"""
1058
 
        if entry.file_id in self._byid:
1059
 
            raise BzrError("inventory already contains entry with id {%s}" %
1060
 
                           entry.file_id)
1061
 
        self._byid[entry.file_id] = entry
1062
 
        for child in getattr(entry, 'children', {}).itervalues():
1063
 
            self._add_child(child)
1064
 
        return entry
1065
967
 
1066
968
    def add(self, entry):
1067
969
        """Add entry to inventory.
1072
974
        Returns the new entry object.
1073
975
        """
1074
976
        if entry.file_id in self._byid:
1075
 
            raise errors.DuplicateFileId(entry.file_id,
1076
 
                                         self._byid[entry.file_id])
1077
 
 
1078
 
        if entry.parent_id is None:
1079
 
            self.root = entry
1080
 
        else:
1081
 
            try:
1082
 
                parent = self._byid[entry.parent_id]
1083
 
            except KeyError:
1084
 
                raise BzrError("parent_id {%s} not in inventory" %
1085
 
                               entry.parent_id)
1086
 
 
1087
 
            if entry.name in parent.children:
1088
 
                raise BzrError("%s is already versioned" %
1089
 
                        osutils.pathjoin(self.id2path(parent.file_id),
1090
 
                        entry.name).encode('utf-8'))
1091
 
            parent.children[entry.name] = entry
1092
 
        return self._add_child(entry)
 
977
            raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
 
978
 
 
979
        if entry.parent_id == ROOT_ID or entry.parent_id is None:
 
980
            entry.parent_id = self.root.file_id
 
981
 
 
982
        try:
 
983
            parent = self._byid[entry.parent_id]
 
984
        except KeyError:
 
985
            raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
 
986
 
 
987
        if parent.children.has_key(entry.name):
 
988
            raise BzrError("%s is already versioned" %
 
989
                    pathjoin(self.id2path(parent.file_id), entry.name))
 
990
 
 
991
        self._byid[entry.file_id] = entry
 
992
        parent.children[entry.name] = entry
 
993
        return entry
 
994
 
1093
995
 
1094
996
    def add_path(self, relpath, kind, file_id=None, parent_id=None):
1095
997
        """Add entry from a path.
1098
1000
 
1099
1001
        Returns the new entry object."""
1100
1002
        
1101
 
        parts = osutils.splitpath(relpath)
 
1003
        parts = bzrlib.osutils.splitpath(relpath)
1102
1004
 
1103
1005
        if len(parts) == 0:
1104
1006
            if file_id is None:
1105
 
                file_id = generate_ids.gen_root_id()
1106
 
            self.root = InventoryDirectory(file_id, '', None)
 
1007
                file_id = bzrlib.workingtree.gen_root_id()
 
1008
            self.root = RootEntry(file_id)
1107
1009
            self._byid = {self.root.file_id: self.root}
1108
 
            return self.root
 
1010
            return
1109
1011
        else:
1110
1012
            parent_path = parts[:-1]
1111
1013
            parent_id = self.path2id(parent_path)
1112
 
            if parent_id is None:
1113
 
                raise errors.NotVersionedError(path=parent_path)
 
1014
            if parent_id == None:
 
1015
                raise NotVersionedError(path=parent_path)
1114
1016
        ie = make_entry(kind, parts[-1], parent_id, file_id)
1115
1017
        return self.add(ie)
1116
1018
 
1119
1021
 
1120
1022
        >>> inv = Inventory()
1121
1023
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1122
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
1024
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
1123
1025
        >>> '123' in inv
1124
1026
        True
1125
1027
        >>> del inv['123']
1127
1029
        False
1128
1030
        """
1129
1031
        ie = self[file_id]
 
1032
 
 
1033
        assert ie.parent_id is None or \
 
1034
            self[ie.parent_id].children[ie.name] == ie
 
1035
        
1130
1036
        del self._byid[file_id]
1131
1037
        if ie.parent_id is not None:
1132
1038
            del self[ie.parent_id].children[ie.name]
1133
1039
 
 
1040
 
1134
1041
    def __eq__(self, other):
1135
1042
        """Compare two sets by comparing their contents.
1136
1043
 
1139
1046
        >>> i1 == i2
1140
1047
        True
1141
1048
        >>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
1142
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
 
1049
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1143
1050
        >>> i1 == i2
1144
1051
        False
1145
1052
        >>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
1146
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
 
1053
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1147
1054
        >>> i1 == i2
1148
1055
        True
1149
1056
        """
1150
1057
        if not isinstance(other, Inventory):
1151
1058
            return NotImplemented
1152
1059
 
 
1060
        if len(self._byid) != len(other._byid):
 
1061
            # shortcut: obviously not the same
 
1062
            return False
 
1063
 
1153
1064
        return self._byid == other._byid
1154
1065
 
 
1066
 
1155
1067
    def __ne__(self, other):
1156
1068
        return not self.__eq__(other)
1157
1069
 
 
1070
 
1158
1071
    def __hash__(self):
1159
1072
        raise ValueError('not hashable')
1160
1073
 
1161
1074
    def _iter_file_id_parents(self, file_id):
1162
1075
        """Yield the parents of file_id up to the root."""
1163
 
        while file_id is not None:
 
1076
        while file_id != None:
1164
1077
            try:
1165
1078
                ie = self._byid[file_id]
1166
1079
            except KeyError:
1167
 
                raise errors.NoSuchId(tree=None, file_id=file_id)
 
1080
                raise BzrError("file_id {%s} not found in inventory" % file_id)
1168
1081
            yield ie
1169
1082
            file_id = ie.parent_id
1170
1083
 
1206
1119
 
1207
1120
        Returns None IFF the path is not found.
1208
1121
        """
1209
 
        if isinstance(name, basestring):
1210
 
            name = osutils.splitpath(name)
 
1122
        if isinstance(name, types.StringTypes):
 
1123
            name = splitpath(name)
1211
1124
 
1212
1125
        # mutter("lookup path %r" % name)
1213
1126
 
1214
1127
        parent = self.root
1215
 
        if parent is None:
1216
 
            return None
1217
1128
        for f in name:
1218
1129
            try:
1219
 
                children = getattr(parent, 'children', None)
1220
 
                if children is None:
1221
 
                    return None
1222
 
                cie = children[f]
 
1130
                cie = parent.children[f]
 
1131
                assert cie.name == f
 
1132
                assert cie.parent_id == parent.file_id
1223
1133
                parent = cie
1224
1134
            except KeyError:
1225
1135
                # or raise an error?
1227
1137
 
1228
1138
        return parent.file_id
1229
1139
 
 
1140
 
1230
1141
    def has_filename(self, names):
1231
1142
        return bool(self.path2id(names))
1232
1143
 
 
1144
 
1233
1145
    def has_id(self, file_id):
1234
 
        return (file_id in self._byid)
 
1146
        return self._byid.has_key(file_id)
1235
1147
 
1236
 
    def remove_recursive_id(self, file_id):
1237
 
        """Remove file_id, and children, from the inventory.
1238
 
        
1239
 
        :param file_id: A file_id to remove.
1240
 
        """
1241
 
        to_find_delete = [self._byid[file_id]]
1242
 
        to_delete = []
1243
 
        while to_find_delete:
1244
 
            ie = to_find_delete.pop()
1245
 
            to_delete.append(ie.file_id)
1246
 
            if ie.kind == 'directory':
1247
 
                to_find_delete.extend(ie.children.values())
1248
 
        for file_id in reversed(to_delete):
1249
 
            ie = self[file_id]
1250
 
            del self._byid[file_id]
1251
 
        if ie.parent_id is not None:
1252
 
            del self[ie.parent_id].children[ie.name]
1253
 
        else:
1254
 
            self.root = None
1255
1148
 
1256
1149
    def rename(self, file_id, new_parent_id, new_name):
1257
1150
        """Move a file within the inventory.
1258
1151
 
1259
1152
        This can change either the name, or the parent, or both.
1260
1153
 
1261
 
        This does not move the working file.
1262
 
        """
1263
 
        new_name = ensure_normalized_name(new_name)
 
1154
        This does not move the working file."""
1264
1155
        if not is_valid_name(new_name):
1265
1156
            raise BzrError("not an acceptable filename: %r" % new_name)
1266
1157
 
1284
1175
        file_ie.name = new_name
1285
1176
        file_ie.parent_id = new_parent_id
1286
1177
 
1287
 
    def is_root(self, file_id):
1288
 
        return self.root is not None and file_id == self.root.file_id
1289
 
 
1290
 
 
1291
 
entry_factory = {
1292
 
    'directory': InventoryDirectory,
1293
 
    'file': InventoryFile,
1294
 
    'symlink': InventoryLink,
1295
 
    'tree-reference': TreeReference
1296
 
}
1297
1178
 
1298
1179
def make_entry(kind, name, parent_id, file_id=None):
1299
1180
    """Create an inventory entry.
1304
1185
    :param file_id: the file_id to use. if None, one will be created.
1305
1186
    """
1306
1187
    if file_id is None:
1307
 
        file_id = generate_ids.gen_file_id(name)
1308
 
    name = ensure_normalized_name(name)
1309
 
    try:
1310
 
        factory = entry_factory[kind]
1311
 
    except KeyError:
 
1188
        file_id = bzrlib.workingtree.gen_file_id(name)
 
1189
    if kind == 'directory':
 
1190
        return InventoryDirectory(file_id, name, parent_id)
 
1191
    elif kind == 'file':
 
1192
        return InventoryFile(file_id, name, parent_id)
 
1193
    elif kind == 'symlink':
 
1194
        return InventoryLink(file_id, name, parent_id)
 
1195
    else:
1312
1196
        raise BzrError("unknown kind %r" % kind)
1313
 
    return factory(file_id, name, parent_id)
1314
 
 
1315
 
 
1316
 
def ensure_normalized_name(name):
1317
 
    """Normalize name.
1318
 
 
1319
 
    :raises InvalidNormalization: When name is not normalized, and cannot be
1320
 
        accessed on this platform by the normalized path.
1321
 
    :return: The NFC normalised version of name.
1322
 
    """
1323
 
    #------- This has been copied to bzrlib.dirstate.DirState.add, please
1324
 
    # keep them synchronised.
1325
 
    # we dont import normalized_filename directly because we want to be
1326
 
    # able to change the implementation at runtime for tests.
1327
 
    norm_name, can_access = osutils.normalized_filename(name)
1328
 
    if norm_name != name:
1329
 
        if can_access:
1330
 
            return norm_name
1331
 
        else:
1332
 
            # TODO: jam 20060701 This would probably be more useful
1333
 
            #       if the error was raised with the full path
1334
 
            raise errors.InvalidNormalization(name)
1335
 
    return name
 
1197
 
1336
1198
 
1337
1199
 
1338
1200
_NAME_RE = None
1339
1201
 
1340
1202
def is_valid_name(name):
1341
1203
    global _NAME_RE
1342
 
    if _NAME_RE is None:
 
1204
    if _NAME_RE == None:
1343
1205
        _NAME_RE = re.compile(r'^[^/\\]+$')
1344
1206
        
1345
1207
    return bool(_NAME_RE.match(name))