← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Martin Pool
  • Date: 2006-02-01 12:24:35 UTC
  • mfrom: (1534.4.32 branch-formats)
  • mto: This revision was merged to the branch mainline in revision 1553.
  • Revision ID: mbp@sourcefrog.net-20060201122435-53f3efb1b5749fe1
[merge] branch-formats branch, and reconcile changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
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
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
 
    )
 
38
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
 
39
                            pathjoin, sha_strings)
53
40
from bzrlib.trace import mutter
 
41
from bzrlib.errors import (NotVersionedError, InvalidEntryName,
 
42
                           BzrError, BzrCheckError)
54
43
 
55
44
 
56
45
class InventoryEntry(object):
87
76
    >>> i.path2id('')
88
77
    'TREE_ROOT'
89
78
    >>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
90
 
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
 
79
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT')
91
80
    >>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
92
 
    InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None)
93
 
    >>> 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')}
94
83
    >>> for ix, j in enumerate(i.iter_entries()):
95
84
    ...   print (j[0] == shouldbe[ix], j[1])
96
85
    ... 
97
 
    (True, InventoryDirectory('TREE_ROOT', u'', parent_id=None, revision=None))
98
 
    (True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None))
99
 
    (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'))
100
88
    >>> i.add(InventoryFile('2323', 'bye.c', '123'))
101
89
    Traceback (most recent call last):
102
90
    ...
103
91
    BzrError: inventory already contains entry with id {2323}
104
92
    >>> i.add(InventoryFile('2324', 'bye.c', '123'))
105
 
    InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None)
 
93
    InventoryFile('2324', 'bye.c', parent_id='123')
106
94
    >>> i.add(InventoryDirectory('2325', 'wibble', '123'))
107
 
    InventoryDirectory('2325', 'wibble', parent_id='123', revision=None)
 
95
    InventoryDirectory('2325', 'wibble', parent_id='123')
108
96
    >>> i.path2id('src/wibble')
109
97
    '2325'
110
98
    >>> '2325' in i
111
99
    True
112
100
    >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
113
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
 
101
    InventoryFile('2326', 'wibble.c', parent_id='2325')
114
102
    >>> i['2326']
115
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
 
103
    InventoryFile('2326', 'wibble.c', parent_id='2325')
116
104
    >>> for path, entry in i.iter_entries():
117
105
    ...     print path
118
106
    ...     assert i.path2id(path)
119
107
    ... 
120
 
    <BLANKLINE>
121
108
    src
122
109
    src/bye.c
123
110
    src/hello.c
126
113
    >>> i.id2path('2326')
127
114
    'src/wibble/wibble.c'
128
115
    """
129
 
 
130
 
    # Constants returned by describe_change()
131
 
    #
132
 
    # TODO: These should probably move to some kind of FileChangeDescription 
133
 
    # class; that's like what's inside a TreeDelta but we want to be able to 
134
 
    # generate them just for one file at a time.
135
 
    RENAMED = 'renamed'
136
 
    MODIFIED_AND_RENAMED = 'modified and renamed'
137
116
    
138
 
    __slots__ = []
 
117
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
 
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)
139
124
 
140
125
    def detect_changes(self, old_entry):
141
126
        """Return a (text_modified, meta_modified) from this to old_entry.
166
151
             output_to, reverse=False):
167
152
        """Perform a diff between two entries of the same kind."""
168
153
 
169
 
    def find_previous_heads(self, previous_inventories,
170
 
                            versioned_file_store,
171
 
                            transaction,
172
 
                            entry_vf=None):
173
 
        """Return the revisions and entries that directly precede this.
 
154
    def find_previous_heads(self, previous_inventories, entry_weave):
 
155
        """Return the revisions and entries that directly preceed this.
174
156
 
175
157
        Returned as a map from revision to inventory entry.
176
158
 
177
159
        This is a map containing the file revisions in all parents
178
160
        for which the file exists, and its revision is not a parent of
179
161
        any other. If the file is new, the set will be empty.
180
 
 
181
 
        :param versioned_file_store: A store where ancestry data on this
182
 
                                     file id can be queried.
183
 
        :param transaction: The transaction that queries to the versioned 
184
 
                            file store should be completed under.
185
 
        :param entry_vf: The entry versioned file, if its already available.
186
162
        """
187
163
        def get_ancestors(weave, entry):
188
 
            return set(weave.get_ancestry(entry.revision))
189
 
        # revision:ie mapping for each ie found in previous_inventories.
190
 
        candidates = {}
191
 
        # revision:ie mapping with one revision for each head.
 
164
            return set(map(weave.idx_to_name,
 
165
                           weave.inclusions([weave.lookup(entry.revision)])))
192
166
        heads = {}
193
 
        # revision: ancestor list for each head
194
167
        head_ancestors = {}
195
 
        # identify candidate head revision ids.
196
168
        for inv in previous_inventories:
197
169
            if self.file_id in inv:
198
170
                ie = inv[self.file_id]
199
171
                assert ie.file_id == self.file_id
200
 
                if ie.revision in candidates:
201
 
                    # same revision value in two different inventories:
202
 
                    # correct possible inconsistencies:
203
 
                    #     * there was a bug in revision updates with 'x' bit 
204
 
                    #       support.
 
172
                if ie.revision in heads:
 
173
                    # fixup logic, there was a bug in revision updates.
 
174
                    # with x bit support.
205
175
                    try:
206
 
                        if candidates[ie.revision].executable != ie.executable:
207
 
                            candidates[ie.revision].executable = False
 
176
                        if heads[ie.revision].executable != ie.executable:
 
177
                            heads[ie.revision].executable = False
208
178
                            ie.executable = False
209
179
                    except AttributeError:
210
180
                        pass
211
 
                    # must now be the same.
212
 
                    assert candidates[ie.revision] == ie
 
181
                    assert heads[ie.revision] == ie
213
182
                else:
214
 
                    # add this revision as a candidate.
215
 
                    candidates[ie.revision] = ie
216
 
 
217
 
        # common case optimisation
218
 
        if len(candidates) == 1:
219
 
            # if there is only one candidate revision found
220
 
            # then we can opening the versioned file to access ancestry:
221
 
            # there cannot be any ancestors to eliminate when there is 
222
 
            # only one revision available.
223
 
            heads[ie.revision] = ie
224
 
            return heads
225
 
 
226
 
        # eliminate ancestors amongst the available candidates:
227
 
        # heads are those that are not an ancestor of any other candidate
228
 
        # - this provides convergence at a per-file level.
229
 
        for ie in candidates.values():
230
 
            # may be an ancestor of a known head:
231
 
            already_present = 0 != len(
232
 
                [head for head in heads 
233
 
                 if ie.revision in head_ancestors[head]])
234
 
            if already_present:
235
 
                # an ancestor of an analyzed candidate.
236
 
                continue
237
 
            # not an ancestor of a known head:
238
 
            # load the versioned file for this file id if needed
239
 
            if entry_vf is None:
240
 
                entry_vf = versioned_file_store.get_weave_or_empty(
241
 
                    self.file_id, transaction)
242
 
            ancestors = get_ancestors(entry_vf, ie)
243
 
            # may knock something else out:
244
 
            check_heads = list(heads.keys())
245
 
            for head in check_heads:
246
 
                if head in ancestors:
247
 
                    # this previously discovered 'head' is not
248
 
                    # really a head - its an ancestor of the newly 
249
 
                    # found head,
250
 
                    heads.pop(head)
251
 
            head_ancestors[ie.revision] = ancestors
252
 
            heads[ie.revision] = ie
 
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
253
201
        return heads
254
202
 
255
203
    def get_tar_item(self, root, dp, now, tree):
256
204
        """Get a tarfile item and a file stream for its content."""
257
 
        item = tarfile.TarInfo(osutils.pathjoin(root, dp).encode('utf8'))
 
205
        item = tarfile.TarInfo(pathjoin(root, dp))
258
206
        # TODO: would be cool to actually set it to the timestamp of the
259
207
        # revision it was last changed
260
208
        item.mtime = now
289
237
        """
290
238
        assert isinstance(name, basestring), name
291
239
        if '/' in name or '\\' in name:
292
 
            raise errors.InvalidEntryName(name=name)
 
240
            raise InvalidEntryName(name=name)
293
241
        self.executable = False
294
242
        self.revision = None
295
243
        self.text_sha1 = None
296
244
        self.text_size = None
297
245
        self.file_id = file_id
298
 
        assert isinstance(file_id, (str, None.__class__)), \
299
 
            'bad type %r for %r' % (type(file_id), file_id)
300
246
        self.name = name
301
247
        self.text_id = text_id
302
248
        self.parent_id = parent_id
306
252
        """Return a short kind indicator useful for appending to names."""
307
253
        raise BzrError('unknown kind %r' % self.kind)
308
254
 
309
 
    known_kinds = ('file', 'directory', 'symlink')
 
255
    known_kinds = ('file', 'directory', 'symlink', 'root_directory')
310
256
 
311
257
    def _put_in_tar(self, item, tree):
312
258
        """populate item for stashing in a tar, and return the content stream.
321
267
        
322
268
        This is a template method - implement _put_on_disk in subclasses.
323
269
        """
324
 
        fullpath = osutils.pathjoin(dest, dp)
 
270
        fullpath = pathjoin(dest, dp)
325
271
        self._put_on_disk(fullpath, tree)
326
 
        # mutter("  export {%s} kind %s to %s", self.file_id,
327
 
        #         self.kind, fullpath)
 
272
        mutter("  export {%s} kind %s to %s", self.file_id,
 
273
                self.kind, fullpath)
328
274
 
329
275
    def _put_on_disk(self, fullpath, tree):
330
276
        """Put this entry onto disk at fullpath, from tree tree."""
331
277
        raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
332
278
 
333
279
    def sorted_children(self):
334
 
        return sorted(self.children.items())
 
280
        l = self.children.items()
 
281
        l.sort()
 
282
        return l
335
283
 
336
284
    @staticmethod
337
285
    def versionable_kind(kind):
338
 
        return (kind in ('file', 'directory', 'symlink'))
 
286
        return kind in ('file', 'directory', 'symlink')
339
287
 
340
288
    def check(self, checker, rev_id, inv, tree):
341
289
        """Check this inventory entry is intact.
342
290
 
343
291
        This is a template method, override _check for kind specific
344
292
        tests.
345
 
 
346
 
        :param checker: Check object providing context for the checks; 
347
 
             can be used to find out what parts of the repository have already
348
 
             been checked.
349
 
        :param rev_id: Revision id from which this InventoryEntry was loaded.
350
 
             Not necessarily the last-changed revision for this file.
351
 
        :param inv: Inventory from which the entry was loaded.
352
 
        :param tree: RevisionTree for this entry.
353
293
        """
354
 
        if self.parent_id is not None:
 
294
        if self.parent_id != None:
355
295
            if not inv.has_id(self.parent_id):
356
296
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
357
297
                        % (self.parent_id, rev_id))
362
302
        raise BzrCheckError('unknown entry kind %r in revision {%s}' % 
363
303
                            (self.kind, rev_id))
364
304
 
 
305
 
365
306
    def copy(self):
366
307
        """Clone this inventory entry."""
367
308
        raise NotImplementedError
368
309
 
369
 
    @staticmethod
370
 
    def describe_change(old_entry, new_entry):
371
 
        """Describe the change between old_entry and this.
372
 
        
373
 
        This smells of being an InterInventoryEntry situation, but as its
374
 
        the first one, we're making it a static method for now.
375
 
 
376
 
        An entry with a different parent, or different name is considered 
377
 
        to be renamed. Reparenting is an internal detail.
378
 
        Note that renaming the parent does not trigger a rename for the
379
 
        child entry itself.
380
 
        """
381
 
        # TODO: Perhaps return an object rather than just a string
382
 
        if old_entry is new_entry:
383
 
            # also the case of both being None
384
 
            return 'unchanged'
385
 
        elif old_entry is None:
 
310
    def _get_snapshot_change(self, previous_entries):
 
311
        if len(previous_entries) > 1:
 
312
            return 'merged'
 
313
        elif len(previous_entries) == 0:
386
314
            return 'added'
387
 
        elif new_entry is None:
388
 
            return 'removed'
389
 
        if old_entry.kind != new_entry.kind:
390
 
            return 'modified'
391
 
        text_modified, meta_modified = new_entry.detect_changes(old_entry)
392
 
        if text_modified or meta_modified:
393
 
            modified = True
394
 
        else:
395
 
            modified = False
396
 
        # TODO 20060511 (mbp, rbc) factor out 'detect_rename' here.
397
 
        if old_entry.parent_id != new_entry.parent_id:
398
 
            renamed = True
399
 
        elif old_entry.name != new_entry.name:
400
 
            renamed = True
401
 
        else:
402
 
            renamed = False
403
 
        if renamed and not modified:
404
 
            return InventoryEntry.RENAMED
405
 
        if modified and not renamed:
406
 
            return 'modified'
407
 
        if modified and renamed:
408
 
            return InventoryEntry.MODIFIED_AND_RENAMED
409
 
        return 'unchanged'
 
315
        else:
 
316
            return 'modified/renamed/reparented'
410
317
 
411
318
    def __repr__(self):
412
 
        return ("%s(%r, %r, parent_id=%r, revision=%r)"
 
319
        return ("%s(%r, %r, parent_id=%r)"
413
320
                % (self.__class__.__name__,
414
321
                   self.file_id,
415
322
                   self.name,
416
 
                   self.parent_id,
417
 
                   self.revision))
 
323
                   self.parent_id))
418
324
 
419
325
    def snapshot(self, revision, path, previous_entries,
420
 
                 work_tree, commit_builder):
 
326
                 work_tree, weave_store, transaction):
421
327
        """Make a snapshot of this entry which may or may not have changed.
422
328
        
423
329
        This means that all its fields are populated, that it has its
424
330
        text stored in the text store or weave.
425
331
        """
426
 
        # mutter('new parents of %s are %r', path, previous_entries)
 
332
        mutter('new parents of %s are %r', path, previous_entries)
427
333
        self._read_tree_state(path, work_tree)
428
 
        # TODO: Where should we determine whether to reuse a
429
 
        # previous revision id or create a new revision? 20060606
430
334
        if len(previous_entries) == 1:
431
335
            # cannot be unchanged unless there is only one parent file rev.
432
336
            parent_ie = previous_entries.values()[0]
433
337
            if self._unchanged(parent_ie):
434
 
                # mutter("found unchanged entry")
 
338
                mutter("found unchanged entry")
435
339
                self.revision = parent_ie.revision
436
340
                return "unchanged"
437
 
        return self._snapshot_into_revision(revision, previous_entries, 
438
 
                                            work_tree, commit_builder)
439
 
 
440
 
    def _snapshot_into_revision(self, revision, previous_entries, work_tree,
441
 
                                commit_builder):
442
 
        """Record this revision unconditionally into a store.
443
 
 
444
 
        The entry's last-changed revision property (`revision`) is updated to 
445
 
        that of the new revision.
446
 
        
447
 
        :param revision: id of the new revision that is being recorded.
448
 
 
449
 
        :returns: String description of the commit (e.g. "merged", "modified"), etc.
450
 
        """
451
 
        # mutter('new revision {%s} for {%s}', revision, self.file_id)
 
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)
452
348
        self.revision = revision
453
 
        self._snapshot_text(previous_entries, work_tree, commit_builder)
 
349
        change = self._get_snapshot_change(previous_entries)
 
350
        self._snapshot_text(previous_entries, work_tree, weave_store,
 
351
                            transaction)
 
352
        return change
454
353
 
455
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder): 
 
354
    def _snapshot_text(self, file_parents, work_tree, weave_store, transaction): 
456
355
        """Record the 'text' of this entry, whatever form that takes.
457
356
        
458
357
        This default implementation simply adds an empty text.
459
358
        """
460
 
        raise NotImplementedError(self._snapshot_text)
 
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)
461
362
 
462
363
    def __eq__(self, other):
463
364
        if not isinstance(other, InventoryEntry):
484
385
    def _unchanged(self, previous_ie):
485
386
        """Has this entry changed relative to previous_ie.
486
387
 
487
 
        This method should be overridden in child classes.
 
388
        This method should be overriden in child classes.
488
389
        """
489
390
        compatible = True
490
391
        # different inv parent
506
407
        # first requested, or preload them if they're already known
507
408
        pass            # nothing to do by default
508
409
 
509
 
    def _forget_tree_state(self):
510
 
        pass
511
 
 
512
410
 
513
411
class RootEntry(InventoryEntry):
514
412
 
515
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
516
 
                 'text_id', 'parent_id', 'children', 'executable', 
517
 
                 'revision', 'symlink_target']
518
 
 
519
413
    def _check(self, checker, rev_id, tree):
520
414
        """See InventoryEntry._check"""
521
415
 
522
416
    def __init__(self, file_id):
523
417
        self.file_id = file_id
524
418
        self.children = {}
525
 
        self.kind = 'directory'
 
419
        self.kind = 'root_directory'
526
420
        self.parent_id = None
527
421
        self.name = u''
528
 
        self.revision = None
529
 
        symbol_versioning.warn('RootEntry is deprecated as of bzr 0.10.'
530
 
                               '  Please use InventoryDirectory instead.',
531
 
                               DeprecationWarning, stacklevel=2)
532
422
 
533
423
    def __eq__(self, other):
534
424
        if not isinstance(other, RootEntry):
541
431
class InventoryDirectory(InventoryEntry):
542
432
    """A directory in an inventory."""
543
433
 
544
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
545
 
                 'text_id', 'parent_id', 'children', 'executable', 
546
 
                 'revision', 'symlink_target']
547
 
 
548
434
    def _check(self, checker, rev_id, tree):
549
435
        """See InventoryEntry._check"""
550
 
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
 
436
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
551
437
            raise BzrCheckError('directory {%s} has text in revision {%s}'
552
438
                                % (self.file_id, rev_id))
553
439
 
580
466
        """See InventoryEntry._put_on_disk."""
581
467
        os.mkdir(fullpath)
582
468
 
583
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
584
 
        """See InventoryEntry._snapshot_text."""
585
 
        commit_builder.modified_directory(self.file_id, file_parents)
586
 
 
587
469
 
588
470
class InventoryFile(InventoryEntry):
589
471
    """A file in an inventory."""
590
472
 
591
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
592
 
                 'text_id', 'parent_id', 'children', 'executable', 
593
 
                 'revision', 'symlink_target']
594
 
 
595
 
    def _check(self, checker, tree_revision_id, tree):
 
473
    def _check(self, checker, rev_id, tree):
596
474
        """See InventoryEntry._check"""
597
 
        t = (self.file_id, self.revision)
 
475
        revision = self.revision
 
476
        t = (self.file_id, revision)
598
477
        if t in checker.checked_texts:
599
 
            prev_sha = checker.checked_texts[t]
 
478
            prev_sha = checker.checked_texts[t] 
600
479
            if prev_sha != self.text_sha1:
601
480
                raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
602
 
                                    (self.file_id, tree_revision_id))
 
481
                                    (self.file_id, rev_id))
603
482
            else:
604
483
                checker.repeated_text_cnt += 1
605
484
                return
613
492
            w.check()
614
493
            checker.checked_weaves[self.file_id] = True
615
494
        else:
616
 
            w = tree.get_weave(self.file_id)
 
495
            w = tree.get_weave_prelude(self.file_id)
617
496
 
618
 
        mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)
619
 
        checker.checked_text_cnt += 1
 
497
        mutter('check version {%s} of {%s}', rev_id, self.file_id)
 
498
        checker.checked_text_cnt += 1 
620
499
        # We can't check the length, because Weave doesn't store that
621
500
        # information, and the whole point of looking at the weave's
622
501
        # sha1sum is that we don't have to extract the text.
636
515
 
637
516
    def detect_changes(self, old_entry):
638
517
        """See InventoryEntry.detect_changes."""
639
 
        assert self.text_sha1 is not None
640
 
        assert old_entry.text_sha1 is not None
 
518
        assert self.text_sha1 != None
 
519
        assert old_entry.text_sha1 != None
641
520
        text_modified = (self.text_sha1 != old_entry.text_sha1)
642
521
        meta_modified = (self.executable != old_entry.executable)
643
522
        return text_modified, meta_modified
645
524
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
646
525
             output_to, reverse=False):
647
526
        """See InventoryEntry._diff."""
648
 
        try:
649
 
            from_text = tree.get_file(self.file_id).readlines()
650
 
            if to_entry:
651
 
                to_text = to_tree.get_file(to_entry.file_id).readlines()
652
 
            else:
653
 
                to_text = []
654
 
            if not reverse:
655
 
                text_diff(from_label, from_text,
656
 
                          to_label, to_text, output_to)
657
 
            else:
658
 
                text_diff(to_label, to_text,
659
 
                          from_label, from_text, output_to)
660
 
        except errors.BinaryFile:
661
 
            if reverse:
662
 
                label_pair = (to_label, from_label)
663
 
            else:
664
 
                label_pair = (from_label, to_label)
665
 
            print >> output_to, "Binary files %s and %s differ" % label_pair
 
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)
666
538
 
667
539
    def has_text(self):
668
540
        """See InventoryEntry.has_text."""
689
561
 
690
562
    def _put_on_disk(self, fullpath, tree):
691
563
        """See InventoryEntry._put_on_disk."""
692
 
        osutils.pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
 
564
        pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
693
565
        if tree.is_executable(self.file_id):
694
566
            os.chmod(fullpath, 0755)
695
567
 
696
568
    def _read_tree_state(self, path, work_tree):
697
569
        """See InventoryEntry._read_tree_state."""
698
 
        self.text_sha1 = work_tree.get_file_sha1(self.file_id, path=path)
699
 
        # FIXME: 20050930 probe for the text size when getting sha1
700
 
        # in _read_tree_state
701
 
        self.executable = work_tree.is_executable(self.file_id, path=path)
702
 
 
703
 
    def __repr__(self):
704
 
        return ("%s(%r, %r, parent_id=%r, sha1=%r, len=%s)"
705
 
                % (self.__class__.__name__,
706
 
                   self.file_id,
707
 
                   self.name,
708
 
                   self.parent_id,
709
 
                   self.text_sha1,
710
 
                   self.text_size))
711
 
 
712
 
    def _forget_tree_state(self):
713
 
        self.text_sha1 = None
714
 
 
715
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
 
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):
716
574
        """See InventoryEntry._snapshot_text."""
717
 
        def get_content_byte_lines():
718
 
            return work_tree.get_file(self.file_id).readlines()
719
 
        self.text_sha1, self.text_size = commit_builder.modified_file_text(
720
 
            self.file_id, file_parents, get_content_byte_lines, self.text_sha1, self.text_size)
 
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
 
721
593
 
722
594
    def _unchanged(self, previous_ie):
723
595
        """See InventoryEntry._unchanged."""
736
608
class InventoryLink(InventoryEntry):
737
609
    """A file in an inventory."""
738
610
 
739
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
740
 
                 'text_id', 'parent_id', 'children', 'executable', 
741
 
                 'revision', 'symlink_target']
 
611
    __slots__ = ['symlink_target']
742
612
 
743
613
    def _check(self, checker, rev_id, tree):
744
614
        """See InventoryEntry._check"""
745
 
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
 
615
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
746
616
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
747
617
                    % (self.file_id, rev_id))
748
 
        if self.symlink_target is None:
 
618
        if self.symlink_target == None:
749
619
            raise BzrCheckError('symlink {%s} has no target in revision {%s}'
750
620
                    % (self.file_id, rev_id))
751
621
 
809
679
        """See InventoryEntry._read_tree_state."""
810
680
        self.symlink_target = work_tree.get_symlink_target(self.file_id)
811
681
 
812
 
    def _forget_tree_state(self):
813
 
        self.symlink_target = None
814
 
 
815
682
    def _unchanged(self, previous_ie):
816
683
        """See InventoryEntry._unchanged."""
817
684
        compatible = super(InventoryLink, self)._unchanged(previous_ie)
819
686
            compatible = False
820
687
        return compatible
821
688
 
822
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
823
 
        """See InventoryEntry._snapshot_text."""
824
 
        commit_builder.modified_link(
825
 
            self.file_id, file_parents, self.symlink_target)
826
 
 
827
689
 
828
690
class Inventory(object):
829
691
    """Inventory of versioned files in a tree.
844
706
 
845
707
    >>> inv = Inventory()
846
708
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
847
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
709
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
848
710
    >>> inv['123-123'].name
849
711
    'hello.c'
850
712
 
858
720
    May also look up by name:
859
721
 
860
722
    >>> [x[0] for x in inv.iter_entries()]
861
 
    ['', u'hello.c']
 
723
    ['hello.c']
862
724
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
863
725
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
864
 
    Traceback (most recent call last):
865
 
    BzrError: parent_id {TREE_ROOT} not in inventory
866
 
    >>> inv.add(InventoryFile('123-123', 'hello.c', 'TREE_ROOT-12345678-12345678'))
867
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678', sha1=None, len=None)
 
726
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
868
727
    """
869
 
    def __init__(self, root_id=ROOT_ID, revision_id=None):
 
728
    def __init__(self, root_id=ROOT_ID):
870
729
        """Create or read an inventory.
871
730
 
872
731
        If a working directory is specified, the inventory is read
876
735
        The inventory is created with a default root directory, with
877
736
        an id of None.
878
737
        """
879
 
        if root_id is not None:
880
 
            assert root_id.__class__ == str
881
 
            self._set_root(InventoryDirectory(root_id, u'', None))
882
 
        else:
883
 
            self.root = None
884
 
            self._byid = {}
885
 
        self.revision_id = revision_id
886
 
 
887
 
    def _set_root(self, ie):
888
 
        self.root = ie
 
738
        # We are letting Branch.create() create a unique inventory
 
739
        # root id. Rather than generating a random one here.
 
740
        #if root_id is None:
 
741
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
 
742
        self.root = RootEntry(root_id)
889
743
        self._byid = {self.root.file_id: self.root}
890
744
 
 
745
 
891
746
    def copy(self):
892
 
        # TODO: jam 20051218 Should copy also copy the revision_id?
893
 
        entries = self.iter_entries()
894
 
        other = Inventory(entries.next()[1].file_id)
 
747
        other = Inventory(self.root.file_id)
895
748
        # copy recursively so we know directories will be added before
896
749
        # their children.  There are more efficient ways than this...
897
 
        for path, entry in entries():
 
750
        for path, entry in self.iter_entries():
 
751
            if entry == self.root:
 
752
                continue
898
753
            other.add(entry.copy())
899
754
        return other
900
755
 
 
756
 
901
757
    def __iter__(self):
902
758
        return iter(self._byid)
903
759
 
 
760
 
904
761
    def __len__(self):
905
762
        """Returns number of entries."""
906
763
        return len(self._byid)
907
764
 
 
765
 
908
766
    def iter_entries(self, from_dir=None):
909
767
        """Return (path, entry) pairs, in order by name."""
910
 
        if from_dir is None:
911
 
            if self.root is None:
912
 
                return
913
 
            from_dir = self.root
914
 
            yield '', self.root
915
 
        elif isinstance(from_dir, basestring):
916
 
            from_dir = self._byid[from_dir]
917
 
            
918
 
        # unrolling the recursive called changed the time from
919
 
        # 440ms/663ms (inline/total) to 116ms/116ms
920
 
        children = from_dir.children.items()
921
 
        children.sort()
922
 
        children = collections.deque(children)
923
 
        stack = [(u'', children)]
924
 
        while stack:
925
 
            from_dir_relpath, children = stack[-1]
926
 
 
927
 
            while children:
928
 
                name, ie = children.popleft()
929
 
 
930
 
                # we know that from_dir_relpath never ends in a slash
931
 
                # and 'f' doesn't begin with one, we can do a string op, rather
932
 
                # than the checks of pathjoin(), though this means that all paths
933
 
                # start with a slash
934
 
                path = from_dir_relpath + '/' + name
935
 
 
936
 
                yield path[1:], ie
937
 
 
938
 
                if ie.kind != 'directory':
939
 
                    continue
940
 
 
941
 
                # But do this child first
942
 
                new_children = ie.children.items()
943
 
                new_children.sort()
944
 
                new_children = collections.deque(new_children)
945
 
                stack.append((path, new_children))
946
 
                # Break out of inner loop, so that we start outer loop with child
947
 
                break
948
 
            else:
949
 
                # if we finished all children, pop it off the stack
950
 
                stack.pop()
951
 
 
952
 
    def iter_entries_by_dir(self, from_dir=None, specific_file_ids=None):
953
 
        """Iterate over the entries in a directory first order.
954
 
 
955
 
        This returns all entries for a directory before returning
956
 
        the entries for children of a directory. This is not
957
 
        lexicographically sorted order, and is a hybrid between
958
 
        depth-first and breadth-first.
959
 
 
960
 
        :return: This yields (path, entry) pairs
961
 
        """
962
 
        if specific_file_ids:
963
 
            specific_file_ids = [osutils.safe_file_id(fid)
964
 
                                 for fid in specific_file_ids]
965
 
        # TODO? Perhaps this should return the from_dir so that the root is
966
 
        # yielded? or maybe an option?
967
 
        if from_dir is None:
968
 
            if self.root is None:
969
 
                return
970
 
            # Optimize a common case
971
 
            if specific_file_ids is not None and len(specific_file_ids) == 1:
972
 
                file_id = list(specific_file_ids)[0]
973
 
                if file_id in self:
974
 
                    yield self.id2path(file_id), self[file_id]
975
 
                return 
976
 
            from_dir = self.root
977
 
            if (specific_file_ids is None or 
978
 
                self.root.file_id in specific_file_ids):
979
 
                yield u'', self.root
980
 
        elif isinstance(from_dir, basestring):
981
 
            from_dir = self._byid[from_dir]
982
 
 
983
 
        if specific_file_ids is not None:
984
 
            parents = set()
985
 
            def add_ancestors(file_id):
986
 
                if file_id not in self:
987
 
                    return
988
 
                parent_id = self[file_id].parent_id
989
 
                if parent_id is None:
990
 
                    return
991
 
                if parent_id not in parents:
992
 
                    parents.add(parent_id)
993
 
                    add_ancestors(parent_id)
994
 
            for file_id in specific_file_ids:
995
 
                add_ancestors(file_id)
996
 
        else:
997
 
            parents = None
998
 
            
999
 
        stack = [(u'', from_dir)]
1000
 
        while stack:
1001
 
            cur_relpath, cur_dir = stack.pop()
1002
 
 
1003
 
            child_dirs = []
1004
 
            for child_name, child_ie in sorted(cur_dir.children.iteritems()):
1005
 
 
1006
 
                child_relpath = cur_relpath + child_name
1007
 
 
1008
 
                if (specific_file_ids is None or 
1009
 
                    child_ie.file_id in specific_file_ids):
1010
 
                    yield child_relpath, child_ie
1011
 
 
1012
 
                if child_ie.kind == 'directory':
1013
 
                    if parents is None or child_ie.file_id in parents:
1014
 
                        child_dirs.append((child_relpath+'/', child_ie))
1015
 
            stack.extend(reversed(child_dirs))
 
768
        if from_dir == None:
 
769
            assert self.root
 
770
            from_dir = self.root
 
771
        elif isinstance(from_dir, basestring):
 
772
            from_dir = self._byid[from_dir]
 
773
            
 
774
        kids = from_dir.children.items()
 
775
        kids.sort()
 
776
        for name, ie in kids:
 
777
            yield name, ie
 
778
            if ie.kind == 'directory':
 
779
                for cn, cie in self.iter_entries(from_dir=ie.file_id):
 
780
                    yield pathjoin(name, cn), cie
 
781
 
1016
782
 
1017
783
    def entries(self):
1018
784
        """Return list of (path, ie) for all entries except the root.
1024
790
            kids = dir_ie.children.items()
1025
791
            kids.sort()
1026
792
            for name, ie in kids:
1027
 
                child_path = osutils.pathjoin(dir_path, name)
 
793
                child_path = pathjoin(dir_path, name)
1028
794
                accum.append((child_path, ie))
1029
795
                if ie.kind == 'directory':
1030
796
                    descend(ie, child_path)
1032
798
        descend(self.root, u'')
1033
799
        return accum
1034
800
 
 
801
 
1035
802
    def directories(self):
1036
803
        """Return (path, entry) pairs for all directories, including the root.
1037
804
        """
1043
810
            kids.sort()
1044
811
 
1045
812
            for name, child_ie in kids:
1046
 
                child_path = osutils.pathjoin(parent_path, name)
 
813
                child_path = pathjoin(parent_path, name)
1047
814
                descend(child_ie, child_path)
1048
815
        descend(self.root, u'')
1049
816
        return accum
1050
817
        
 
818
 
 
819
 
1051
820
    def __contains__(self, file_id):
1052
821
        """True if this entry contains a file with given id.
1053
822
 
1054
823
        >>> inv = Inventory()
1055
824
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1056
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
825
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
1057
826
        >>> '123' in inv
1058
827
        True
1059
828
        >>> '456' in inv
1060
829
        False
1061
830
        """
1062
 
        file_id = osutils.safe_file_id(file_id)
1063
 
        return (file_id in self._byid)
 
831
        return file_id in self._byid
 
832
 
1064
833
 
1065
834
    def __getitem__(self, file_id):
1066
835
        """Return the entry for given file_id.
1067
836
 
1068
837
        >>> inv = Inventory()
1069
838
        >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
1070
 
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
839
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
1071
840
        >>> inv['123123'].name
1072
841
        'hello.c'
1073
842
        """
1074
 
        file_id = osutils.safe_file_id(file_id)
1075
843
        try:
1076
844
            return self._byid[file_id]
1077
845
        except KeyError:
1078
 
            # really we're passing an inventory, not a tree...
1079
 
            raise errors.NoSuchId(self, file_id)
 
846
            if file_id == None:
 
847
                raise BzrError("can't look up file_id None")
 
848
            else:
 
849
                raise BzrError("file_id {%s} not in inventory" % file_id)
 
850
 
1080
851
 
1081
852
    def get_file_kind(self, file_id):
1082
 
        file_id = osutils.safe_file_id(file_id)
1083
853
        return self._byid[file_id].kind
1084
854
 
1085
855
    def get_child(self, parent_id, filename):
1086
 
        parent_id = osutils.safe_file_id(parent_id)
1087
856
        return self[parent_id].children.get(filename)
1088
857
 
 
858
 
1089
859
    def add(self, entry):
1090
860
        """Add entry to inventory.
1091
861
 
1097
867
        if entry.file_id in self._byid:
1098
868
            raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
1099
869
 
1100
 
        if entry.parent_id is None:
1101
 
            assert self.root is None and len(self._byid) == 0
1102
 
            self._set_root(entry)
1103
 
            return entry
 
870
        if entry.parent_id == ROOT_ID or entry.parent_id is None:
 
871
            entry.parent_id = self.root.file_id
 
872
 
1104
873
        try:
1105
874
            parent = self._byid[entry.parent_id]
1106
875
        except KeyError:
1107
876
            raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
1108
877
 
1109
 
        if entry.name in parent.children:
 
878
        if parent.children.has_key(entry.name):
1110
879
            raise BzrError("%s is already versioned" %
1111
 
                    osutils.pathjoin(self.id2path(parent.file_id), entry.name))
 
880
                    pathjoin(self.id2path(parent.file_id), entry.name))
1112
881
 
1113
882
        self._byid[entry.file_id] = entry
1114
883
        parent.children[entry.name] = entry
1115
884
        return entry
1116
885
 
1117
 
    def add_path(self, relpath, kind, file_id=None, parent_id=None):
 
886
 
 
887
    def add_path(self, relpath, kind, file_id=None):
1118
888
        """Add entry from a path.
1119
889
 
1120
890
        The immediate parent must already be versioned.
1121
891
 
1122
892
        Returns the new entry object."""
 
893
        from bzrlib.workingtree import gen_file_id
1123
894
        
1124
 
        parts = osutils.splitpath(relpath)
1125
 
 
 
895
        parts = bzrlib.osutils.splitpath(relpath)
1126
896
        if len(parts) == 0:
1127
 
            if file_id is None:
1128
 
                file_id = generate_ids.gen_root_id()
1129
 
            else:
1130
 
                file_id = osutils.safe_file_id(file_id)
1131
 
            self.root = InventoryDirectory(file_id, '', None)
1132
 
            self._byid = {self.root.file_id: self.root}
1133
 
            return self.root
 
897
            raise BzrError("cannot re-add root of inventory")
 
898
 
 
899
        if file_id == None:
 
900
            file_id = gen_file_id(relpath)
 
901
 
 
902
        parent_path = parts[:-1]
 
903
        parent_id = self.path2id(parent_path)
 
904
        if parent_id == None:
 
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)
1134
912
        else:
1135
 
            parent_path = parts[:-1]
1136
 
            parent_id = self.path2id(parent_path)
1137
 
            if parent_id is None:
1138
 
                raise errors.NotVersionedError(path=parent_path)
1139
 
        ie = make_entry(kind, parts[-1], parent_id, file_id)
 
913
            raise BzrError("unknown kind %r" % kind)
1140
914
        return self.add(ie)
1141
915
 
 
916
 
1142
917
    def __delitem__(self, file_id):
1143
918
        """Remove entry by id.
1144
919
 
1145
920
        >>> inv = Inventory()
1146
921
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1147
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
922
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
1148
923
        >>> '123' in inv
1149
924
        True
1150
925
        >>> del inv['123']
1151
926
        >>> '123' in inv
1152
927
        False
1153
928
        """
1154
 
        file_id = osutils.safe_file_id(file_id)
1155
929
        ie = self[file_id]
1156
930
 
1157
 
        assert ie.parent_id is None or \
1158
 
            self[ie.parent_id].children[ie.name] == ie
 
931
        assert self[ie.parent_id].children[ie.name] == ie
1159
932
        
 
933
        # TODO: Test deleting all children; maybe hoist to a separate
 
934
        # deltree method?
 
935
        if ie.kind == 'directory':
 
936
            for cie in ie.children.values():
 
937
                del self[cie.file_id]
 
938
            del ie.children
 
939
 
1160
940
        del self._byid[file_id]
1161
 
        if ie.parent_id is not None:
1162
 
            del self[ie.parent_id].children[ie.name]
 
941
        del self[ie.parent_id].children[ie.name]
 
942
 
1163
943
 
1164
944
    def __eq__(self, other):
1165
945
        """Compare two sets by comparing their contents.
1169
949
        >>> i1 == i2
1170
950
        True
1171
951
        >>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
1172
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
 
952
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1173
953
        >>> i1 == i2
1174
954
        False
1175
955
        >>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
1176
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
 
956
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1177
957
        >>> i1 == i2
1178
958
        True
1179
959
        """
1180
960
        if not isinstance(other, Inventory):
1181
961
            return NotImplemented
1182
962
 
 
963
        if len(self._byid) != len(other._byid):
 
964
            # shortcut: obviously not the same
 
965
            return False
 
966
 
1183
967
        return self._byid == other._byid
1184
968
 
 
969
 
1185
970
    def __ne__(self, other):
1186
971
        return not self.__eq__(other)
1187
972
 
 
973
 
1188
974
    def __hash__(self):
1189
975
        raise ValueError('not hashable')
1190
976
 
1191
 
    def _iter_file_id_parents(self, file_id):
1192
 
        """Yield the parents of file_id up to the root."""
1193
 
        file_id = osutils.safe_file_id(file_id)
1194
 
        while file_id is not None:
1195
 
            try:
1196
 
                ie = self._byid[file_id]
1197
 
            except KeyError:
1198
 
                raise BzrError("file_id {%s} not found in inventory" % file_id)
1199
 
            yield ie
1200
 
            file_id = ie.parent_id
1201
977
 
1202
978
    def get_idpath(self, file_id):
1203
979
        """Return a list of file_ids for the path to an entry.
1207
983
        is equal to the depth of the file in the tree, counting the
1208
984
        root directory as depth 1.
1209
985
        """
1210
 
        file_id = osutils.safe_file_id(file_id)
1211
986
        p = []
1212
 
        for parent in self._iter_file_id_parents(file_id):
1213
 
            p.insert(0, parent.file_id)
 
987
        while file_id != None:
 
988
            try:
 
989
                ie = self._byid[file_id]
 
990
            except KeyError:
 
991
                raise BzrError("file_id {%s} not found in inventory" % file_id)
 
992
            p.insert(0, ie.file_id)
 
993
            file_id = ie.parent_id
1214
994
        return p
1215
995
 
 
996
 
1216
997
    def id2path(self, file_id):
1217
 
        """Return as a string the path to file_id.
 
998
        """Return as a list the path to file_id.
1218
999
        
1219
1000
        >>> i = Inventory()
1220
1001
        >>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))
1222
1003
        >>> print i.id2path('foo-id')
1223
1004
        src/foo.c
1224
1005
        """
1225
 
        file_id = osutils.safe_file_id(file_id)
1226
1006
        # get all names, skipping root
1227
 
        return '/'.join(reversed(
1228
 
            [parent.name for parent in 
1229
 
             self._iter_file_id_parents(file_id)][:-1]))
 
1007
        p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
 
1008
        if p:
 
1009
            return pathjoin(*p)
 
1010
        else:
 
1011
            return ''
1230
1012
            
 
1013
 
 
1014
 
1231
1015
    def path2id(self, name):
1232
1016
        """Walk down through directories to return entry of last component.
1233
1017
 
1237
1021
        This returns the entry of the last component in the path,
1238
1022
        which may be either a file or a directory.
1239
1023
 
1240
 
        Returns None IFF the path is not found.
 
1024
        Returns None iff the path is not found.
1241
1025
        """
1242
 
        if isinstance(name, basestring):
1243
 
            name = osutils.splitpath(name)
 
1026
        if isinstance(name, types.StringTypes):
 
1027
            name = splitpath(name)
1244
1028
 
1245
 
        # mutter("lookup path %r" % name)
 
1029
        mutter("lookup path %r" % name)
1246
1030
 
1247
1031
        parent = self.root
1248
 
        if parent is None:
1249
 
            return None
1250
1032
        for f in name:
1251
1033
            try:
1252
 
                children = getattr(parent, 'children', None)
1253
 
                if children is None:
1254
 
                    return None
1255
 
                cie = children[f]
 
1034
                cie = parent.children[f]
1256
1035
                assert cie.name == f
1257
1036
                assert cie.parent_id == parent.file_id
1258
1037
                parent = cie
1262
1041
 
1263
1042
        return parent.file_id
1264
1043
 
 
1044
 
1265
1045
    def has_filename(self, names):
1266
1046
        return bool(self.path2id(names))
1267
1047
 
 
1048
 
1268
1049
    def has_id(self, file_id):
1269
 
        file_id = osutils.safe_file_id(file_id)
1270
 
        return (file_id in self._byid)
 
1050
        return self._byid.has_key(file_id)
1271
1051
 
1272
 
    def remove_recursive_id(self, file_id):
1273
 
        """Remove file_id, and children, from the inventory.
1274
 
        
1275
 
        :param file_id: A file_id to remove.
1276
 
        """
1277
 
        file_id = osutils.safe_file_id(file_id)
1278
 
        to_find_delete = [self._byid[file_id]]
1279
 
        to_delete = []
1280
 
        while to_find_delete:
1281
 
            ie = to_find_delete.pop()
1282
 
            to_delete.append(ie.file_id)
1283
 
            if ie.kind == 'directory':
1284
 
                to_find_delete.extend(ie.children.values())
1285
 
        for file_id in reversed(to_delete):
1286
 
            ie = self[file_id]
1287
 
            del self._byid[file_id]
1288
 
            if ie.parent_id is not None:
1289
 
                del self[ie.parent_id].children[ie.name]
1290
1052
 
1291
1053
    def rename(self, file_id, new_parent_id, new_name):
1292
1054
        """Move a file within the inventory.
1293
1055
 
1294
1056
        This can change either the name, or the parent, or both.
1295
1057
 
1296
 
        This does not move the working file.
1297
 
        """
1298
 
        file_id = osutils.safe_file_id(file_id)
 
1058
        This does not move the working file."""
1299
1059
        if not is_valid_name(new_name):
1300
1060
            raise BzrError("not an acceptable filename: %r" % new_name)
1301
1061
 
1319
1079
        file_ie.name = new_name
1320
1080
        file_ie.parent_id = new_parent_id
1321
1081
 
1322
 
    def is_root(self, file_id):
1323
 
        file_id = osutils.safe_file_id(file_id)
1324
 
        return self.root is not None and file_id == self.root.file_id
1325
 
 
1326
 
 
1327
 
entry_factory = {
1328
 
    'directory':InventoryDirectory,
1329
 
    'file':InventoryFile,
1330
 
    'symlink':InventoryLink,
1331
 
}
1332
 
 
1333
 
def make_entry(kind, name, parent_id, file_id=None):
1334
 
    """Create an inventory entry.
1335
 
 
1336
 
    :param kind: the type of inventory entry to create.
1337
 
    :param name: the basename of the entry.
1338
 
    :param parent_id: the parent_id of the entry.
1339
 
    :param file_id: the file_id to use. if None, one will be created.
1340
 
    """
1341
 
    if file_id is None:
1342
 
        file_id = generate_ids.gen_file_id(name)
1343
 
    else:
1344
 
        file_id = osutils.safe_file_id(file_id)
1345
 
 
1346
 
    #------- This has been copied to bzrlib.dirstate.DirState.add, please
1347
 
    # keep them synchronised.
1348
 
    # we dont import normalized_filename directly because we want to be
1349
 
    # able to change the implementation at runtime for tests.
1350
 
    norm_name, can_access = osutils.normalized_filename(name)
1351
 
    if norm_name != name:
1352
 
        if can_access:
1353
 
            name = norm_name
1354
 
        else:
1355
 
            # TODO: jam 20060701 This would probably be more useful
1356
 
            #       if the error was raised with the full path
1357
 
            raise errors.InvalidNormalization(name)
1358
 
 
1359
 
    try:
1360
 
        factory = entry_factory[kind]
1361
 
    except KeyError:
1362
 
        raise BzrError("unknown kind %r" % kind)
1363
 
    return factory(file_id, name, parent_id)
 
1082
 
1364
1083
 
1365
1084
 
1366
1085
_NAME_RE = None
1367
1086
 
1368
1087
def is_valid_name(name):
1369
1088
    global _NAME_RE
1370
 
    if _NAME_RE is None:
 
1089
    if _NAME_RE == None:
1371
1090
        _NAME_RE = re.compile(r'^[^/\\]+$')
1372
1091
        
1373
1092
    return bool(_NAME_RE.match(name))