← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Aaron Bentley
  • Date: 2005-10-18 18:48:27 UTC
  • mto: (1185.25.1)
  • mto: This revision was merged to the branch mainline in revision 1474.
  • Revision ID: abentley@panoramicfeedback.com-20051018184827-2cc69376beb1cdf3
Switched to ConfigObj

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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
# FIXME: This refactoring of the workingtree code doesn't seem to keep 
18
 
# the WorkingTree's copy of the inventory in sync with the branch.  The
19
 
# branch modifies its working inventory when it does a commit to make
20
 
# missing files permanently removed.
21
17
 
22
18
# TODO: Maybe also keep the full path of the entry, and the children?
23
19
# But those depend on its position within a particular inventory, and
28
24
ROOT_ID = "TREE_ROOT"
29
25
 
30
26
 
31
 
import collections
32
27
import os.path
33
28
import re
34
29
import sys
35
30
import tarfile
36
31
import types
37
 
from warnings import warn
38
32
 
39
33
import bzrlib
40
 
from bzrlib import errors, osutils
 
34
from bzrlib.errors import BzrError, BzrCheckError
 
35
 
41
36
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
42
 
                            pathjoin, sha_strings)
43
 
from bzrlib.errors import (NotVersionedError, InvalidEntryName,
44
 
                           BzrError, BzrCheckError, BinaryFile)
 
37
                            appendpath, sha_strings)
45
38
from bzrlib.trace import mutter
 
39
from bzrlib.errors import NotVersionedError
46
40
 
47
41
 
48
42
class InventoryEntry(object):
79
73
    >>> i.path2id('')
80
74
    'TREE_ROOT'
81
75
    >>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
82
 
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
 
76
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT')
83
77
    >>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
84
 
    InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None)
85
 
    >>> shouldbe = {0: '', 1: 'src', 2: pathjoin('src','hello.c')}
86
 
    >>> for ix, j in enumerate(i.iter_entries()):
87
 
    ...   print (j[0] == shouldbe[ix], j[1])
 
78
    InventoryFile('2323', 'hello.c', parent_id='123')
 
79
    >>> for j in i.iter_entries():
 
80
    ...   print j
88
81
    ... 
89
 
    (True, InventoryDirectory('TREE_ROOT', '', parent_id=None, revision=None))
90
 
    (True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None))
91
 
    (True, InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None))
 
82
    ('src', InventoryDirectory('123', 'src', parent_id='TREE_ROOT'))
 
83
    ('src/hello.c', InventoryFile('2323', 'hello.c', parent_id='123'))
92
84
    >>> i.add(InventoryFile('2323', 'bye.c', '123'))
93
85
    Traceback (most recent call last):
94
86
    ...
95
87
    BzrError: inventory already contains entry with id {2323}
96
88
    >>> i.add(InventoryFile('2324', 'bye.c', '123'))
97
 
    InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None)
 
89
    InventoryFile('2324', 'bye.c', parent_id='123')
98
90
    >>> i.add(InventoryDirectory('2325', 'wibble', '123'))
99
 
    InventoryDirectory('2325', 'wibble', parent_id='123', revision=None)
 
91
    InventoryDirectory('2325', 'wibble', parent_id='123')
100
92
    >>> i.path2id('src/wibble')
101
93
    '2325'
102
94
    >>> '2325' in i
103
95
    True
104
96
    >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
105
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
 
97
    InventoryFile('2326', 'wibble.c', parent_id='2325')
106
98
    >>> i['2326']
107
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
 
99
    InventoryFile('2326', 'wibble.c', parent_id='2325')
108
100
    >>> for path, entry in i.iter_entries():
109
 
    ...     print path
 
101
    ...     print path.replace('\\\\', '/')     # for win32 os.sep
110
102
    ...     assert i.path2id(path)
111
103
    ... 
112
 
    <BLANKLINE>
113
104
    src
114
105
    src/bye.c
115
106
    src/hello.c
116
107
    src/wibble
117
108
    src/wibble/wibble.c
118
 
    >>> i.id2path('2326')
 
109
    >>> i.id2path('2326').replace('\\\\', '/')
119
110
    'src/wibble/wibble.c'
120
111
    """
121
 
 
122
 
    # Constants returned by describe_change()
123
 
    #
124
 
    # TODO: These should probably move to some kind of FileChangeDescription 
125
 
    # class; that's like what's inside a TreeDelta but we want to be able to 
126
 
    # generate them just for one file at a time.
127
 
    RENAMED = 'renamed'
128
 
    MODIFIED_AND_RENAMED = 'modified and renamed'
129
112
    
130
 
    __slots__ = []
 
113
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
 
114
                 'text_id', 'parent_id', 'children', 'executable', 
 
115
                 'revision']
 
116
 
 
117
    def _add_text_to_weave(self, new_lines, parents, weave_store, transaction):
 
118
        weave_store.add_text(self.file_id, self.revision, new_lines, parents,
 
119
                             transaction)
131
120
 
132
121
    def detect_changes(self, old_entry):
133
122
        """Return a (text_modified, meta_modified) from this to old_entry.
158
147
             output_to, reverse=False):
159
148
        """Perform a diff between two entries of the same kind."""
160
149
 
161
 
    def find_previous_heads(self, previous_inventories,
162
 
                            versioned_file_store,
163
 
                            transaction,
164
 
                            entry_vf=None):
165
 
        """Return the revisions and entries that directly precede this.
 
150
    def find_previous_heads(self, previous_inventories, entry_weave):
 
151
        """Return the revisions and entries that directly preceed this.
166
152
 
167
153
        Returned as a map from revision to inventory entry.
168
154
 
169
155
        This is a map containing the file revisions in all parents
170
156
        for which the file exists, and its revision is not a parent of
171
157
        any other. If the file is new, the set will be empty.
172
 
 
173
 
        :param versioned_file_store: A store where ancestry data on this
174
 
                                     file id can be queried.
175
 
        :param transaction: The transaction that queries to the versioned 
176
 
                            file store should be completed under.
177
 
        :param entry_vf: The entry versioned file, if its already available.
178
158
        """
179
159
        def get_ancestors(weave, entry):
180
 
            return set(weave.get_ancestry(entry.revision))
181
 
        # revision:ie mapping for each ie found in previous_inventories.
182
 
        candidates = {}
183
 
        # revision:ie mapping with one revision for each head.
 
160
            return set(map(weave.idx_to_name,
 
161
                           weave.inclusions([weave.lookup(entry.revision)])))
184
162
        heads = {}
185
 
        # revision: ancestor list for each head
186
163
        head_ancestors = {}
187
 
        # identify candidate head revision ids.
188
164
        for inv in previous_inventories:
189
165
            if self.file_id in inv:
190
166
                ie = inv[self.file_id]
191
167
                assert ie.file_id == self.file_id
192
 
                if ie.revision in candidates:
193
 
                    # same revision value in two different inventories:
194
 
                    # correct possible inconsistencies:
195
 
                    #     * there was a bug in revision updates with 'x' bit 
196
 
                    #       support.
 
168
                if ie.revision in heads:
 
169
                    # fixup logic, there was a bug in revision updates.
 
170
                    # with x bit support.
197
171
                    try:
198
 
                        if candidates[ie.revision].executable != ie.executable:
199
 
                            candidates[ie.revision].executable = False
 
172
                        if heads[ie.revision].executable != ie.executable:
 
173
                            heads[ie.revision].executable = False
200
174
                            ie.executable = False
201
175
                    except AttributeError:
202
176
                        pass
203
 
                    # must now be the same.
204
 
                    assert candidates[ie.revision] == ie
 
177
                    assert heads[ie.revision] == ie
205
178
                else:
206
 
                    # add this revision as a candidate.
207
 
                    candidates[ie.revision] = ie
208
 
 
209
 
        # common case optimisation
210
 
        if len(candidates) == 1:
211
 
            # if there is only one candidate revision found
212
 
            # then we can opening the versioned file to access ancestry:
213
 
            # there cannot be any ancestors to eliminate when there is 
214
 
            # only one revision available.
215
 
            heads[ie.revision] = ie
216
 
            return heads
217
 
 
218
 
        # eliminate ancestors amongst the available candidates:
219
 
        # heads are those that are not an ancestor of any other candidate
220
 
        # - this provides convergence at a per-file level.
221
 
        for ie in candidates.values():
222
 
            # may be an ancestor of a known head:
223
 
            already_present = 0 != len(
224
 
                [head for head in heads 
225
 
                 if ie.revision in head_ancestors[head]])
226
 
            if already_present:
227
 
                # an ancestor of an analyzed candidate.
228
 
                continue
229
 
            # not an ancestor of a known head:
230
 
            # load the versioned file for this file id if needed
231
 
            if entry_vf is None:
232
 
                entry_vf = versioned_file_store.get_weave_or_empty(
233
 
                    self.file_id, transaction)
234
 
            ancestors = get_ancestors(entry_vf, ie)
235
 
            # may knock something else out:
236
 
            check_heads = list(heads.keys())
237
 
            for head in check_heads:
238
 
                if head in ancestors:
239
 
                    # this previously discovered 'head' is not
240
 
                    # really a head - its an ancestor of the newly 
241
 
                    # found head,
242
 
                    heads.pop(head)
243
 
            head_ancestors[ie.revision] = ancestors
244
 
            heads[ie.revision] = ie
 
179
                    # may want to add it.
 
180
                    # may already be covered:
 
181
                    already_present = 0 != len(
 
182
                        [head for head in heads 
 
183
                         if ie.revision in head_ancestors[head]])
 
184
                    if already_present:
 
185
                        # an ancestor of a known head.
 
186
                        continue
 
187
                    # definately a head:
 
188
                    ancestors = get_ancestors(entry_weave, ie)
 
189
                    # may knock something else out:
 
190
                    check_heads = list(heads.keys())
 
191
                    for head in check_heads:
 
192
                        if head in ancestors:
 
193
                            # this head is not really a head
 
194
                            heads.pop(head)
 
195
                    head_ancestors[ie.revision] = ancestors
 
196
                    heads[ie.revision] = ie
245
197
        return heads
246
198
 
247
199
    def get_tar_item(self, root, dp, now, tree):
248
200
        """Get a tarfile item and a file stream for its content."""
249
 
        item = tarfile.TarInfo(pathjoin(root, dp))
 
201
        item = tarfile.TarInfo(os.path.join(root, dp))
250
202
        # TODO: would be cool to actually set it to the timestamp of the
251
203
        # revision it was last changed
252
204
        item.mtime = now
277
229
        '123'
278
230
        >>> e = InventoryFile('123', 'src/hello.c', ROOT_ID)
279
231
        Traceback (most recent call last):
280
 
        InvalidEntryName: Invalid entry name: src/hello.c
 
232
        BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
281
233
        """
282
234
        assert isinstance(name, basestring), name
283
235
        if '/' in name or '\\' in name:
284
 
            raise InvalidEntryName(name=name)
 
236
            raise BzrCheckError('InventoryEntry name %r is invalid' % name)
 
237
        
285
238
        self.executable = False
286
239
        self.revision = None
287
240
        self.text_sha1 = None
296
249
        """Return a short kind indicator useful for appending to names."""
297
250
        raise BzrError('unknown kind %r' % self.kind)
298
251
 
299
 
    known_kinds = ('file', 'directory', 'symlink')
 
252
    known_kinds = ('file', 'directory', 'symlink', 'root_directory')
300
253
 
301
254
    def _put_in_tar(self, item, tree):
302
255
        """populate item for stashing in a tar, and return the content stream.
311
264
        
312
265
        This is a template method - implement _put_on_disk in subclasses.
313
266
        """
314
 
        fullpath = pathjoin(dest, dp)
 
267
        fullpath = appendpath(dest, dp)
315
268
        self._put_on_disk(fullpath, tree)
316
 
        # mutter("  export {%s} kind %s to %s", self.file_id,
317
 
        #         self.kind, fullpath)
 
269
        mutter("  export {%s} kind %s to %s" % (self.file_id, self.kind, fullpath))
318
270
 
319
271
    def _put_on_disk(self, fullpath, tree):
320
272
        """Put this entry onto disk at fullpath, from tree tree."""
321
273
        raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
322
274
 
323
275
    def sorted_children(self):
324
 
        return sorted(self.children.items())
 
276
        l = self.children.items()
 
277
        l.sort()
 
278
        return l
325
279
 
326
280
    @staticmethod
327
281
    def versionable_kind(kind):
332
286
 
333
287
        This is a template method, override _check for kind specific
334
288
        tests.
335
 
 
336
 
        :param checker: Check object providing context for the checks; 
337
 
             can be used to find out what parts of the repository have already
338
 
             been checked.
339
 
        :param rev_id: Revision id from which this InventoryEntry was loaded.
340
 
             Not necessarily the last-changed revision for this file.
341
 
        :param inv: Inventory from which the entry was loaded.
342
 
        :param tree: RevisionTree for this entry.
343
289
        """
344
 
        if self.parent_id is not None:
 
290
        if self.parent_id != None:
345
291
            if not inv.has_id(self.parent_id):
346
292
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
347
293
                        % (self.parent_id, rev_id))
352
298
        raise BzrCheckError('unknown entry kind %r in revision {%s}' % 
353
299
                            (self.kind, rev_id))
354
300
 
 
301
 
355
302
    def copy(self):
356
303
        """Clone this inventory entry."""
357
304
        raise NotImplementedError
358
305
 
359
 
    @staticmethod
360
 
    def describe_change(old_entry, new_entry):
361
 
        """Describe the change between old_entry and this.
362
 
        
363
 
        This smells of being an InterInventoryEntry situation, but as its
364
 
        the first one, we're making it a static method for now.
365
 
 
366
 
        An entry with a different parent, or different name is considered 
367
 
        to be renamed. Reparenting is an internal detail.
368
 
        Note that renaming the parent does not trigger a rename for the
369
 
        child entry itself.
370
 
        """
371
 
        # TODO: Perhaps return an object rather than just a string
372
 
        if old_entry is new_entry:
373
 
            # also the case of both being None
374
 
            return 'unchanged'
375
 
        elif old_entry is None:
 
306
    def _get_snapshot_change(self, previous_entries):
 
307
        if len(previous_entries) > 1:
 
308
            return 'merged'
 
309
        elif len(previous_entries) == 0:
376
310
            return 'added'
377
 
        elif new_entry is None:
378
 
            return 'removed'
379
 
        text_modified, meta_modified = new_entry.detect_changes(old_entry)
380
 
        if text_modified or meta_modified:
381
 
            modified = True
382
 
        else:
383
 
            modified = False
384
 
        # TODO 20060511 (mbp, rbc) factor out 'detect_rename' here.
385
 
        if old_entry.parent_id != new_entry.parent_id:
386
 
            renamed = True
387
 
        elif old_entry.name != new_entry.name:
388
 
            renamed = True
389
 
        else:
390
 
            renamed = False
391
 
        if renamed and not modified:
392
 
            return InventoryEntry.RENAMED
393
 
        if modified and not renamed:
394
 
            return 'modified'
395
 
        if modified and renamed:
396
 
            return InventoryEntry.MODIFIED_AND_RENAMED
397
 
        return 'unchanged'
 
311
        else:
 
312
            return 'modified/renamed/reparented'
398
313
 
399
314
    def __repr__(self):
400
 
        return ("%s(%r, %r, parent_id=%r, revision=%r)"
 
315
        return ("%s(%r, %r, parent_id=%r)"
401
316
                % (self.__class__.__name__,
402
317
                   self.file_id,
403
318
                   self.name,
404
 
                   self.parent_id,
405
 
                   self.revision))
 
319
                   self.parent_id))
406
320
 
407
321
    def snapshot(self, revision, path, previous_entries,
408
 
                 work_tree, commit_builder):
 
322
                 work_tree, weave_store, transaction):
409
323
        """Make a snapshot of this entry which may or may not have changed.
410
324
        
411
325
        This means that all its fields are populated, that it has its
412
326
        text stored in the text store or weave.
413
327
        """
414
 
        # mutter('new parents of %s are %r', path, previous_entries)
 
328
        mutter('new parents of %s are %r', path, previous_entries)
415
329
        self._read_tree_state(path, work_tree)
416
 
        # TODO: Where should we determine whether to reuse a
417
 
        # previous revision id or create a new revision? 20060606
418
330
        if len(previous_entries) == 1:
419
331
            # cannot be unchanged unless there is only one parent file rev.
420
332
            parent_ie = previous_entries.values()[0]
421
333
            if self._unchanged(parent_ie):
422
 
                # mutter("found unchanged entry")
 
334
                mutter("found unchanged entry")
423
335
                self.revision = parent_ie.revision
424
336
                return "unchanged"
425
 
        return self._snapshot_into_revision(revision, previous_entries, 
426
 
                                            work_tree, commit_builder)
427
 
 
428
 
    def _snapshot_into_revision(self, revision, previous_entries, work_tree,
429
 
                                commit_builder):
430
 
        """Record this revision unconditionally into a store.
431
 
 
432
 
        The entry's last-changed revision property (`revision`) is updated to 
433
 
        that of the new revision.
434
 
        
435
 
        :param revision: id of the new revision that is being recorded.
436
 
 
437
 
        :returns: String description of the commit (e.g. "merged", "modified"), etc.
438
 
        """
439
 
        # mutter('new revision {%s} for {%s}', revision, self.file_id)
 
337
        return self.snapshot_revision(revision, previous_entries, 
 
338
                                      work_tree, weave_store, transaction)
 
339
 
 
340
    def snapshot_revision(self, revision, previous_entries, work_tree,
 
341
                          weave_store, transaction):
 
342
        """Record this revision unconditionally."""
 
343
        mutter('new revision for {%s}', self.file_id)
440
344
        self.revision = revision
441
 
        self._snapshot_text(previous_entries, work_tree, commit_builder)
 
345
        change = self._get_snapshot_change(previous_entries)
 
346
        self._snapshot_text(previous_entries, work_tree, weave_store,
 
347
                            transaction)
 
348
        return change
442
349
 
443
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder): 
 
350
    def _snapshot_text(self, file_parents, work_tree, weave_store, transaction): 
444
351
        """Record the 'text' of this entry, whatever form that takes.
445
352
        
446
353
        This default implementation simply adds an empty text.
447
354
        """
448
 
        raise NotImplementedError(self._snapshot_text)
 
355
        mutter('storing file {%s} in revision {%s}',
 
356
               self.file_id, self.revision)
 
357
        self._add_text_to_weave([], file_parents, weave_store, transaction)
449
358
 
450
359
    def __eq__(self, other):
451
360
        if not isinstance(other, InventoryEntry):
472
381
    def _unchanged(self, previous_ie):
473
382
        """Has this entry changed relative to previous_ie.
474
383
 
475
 
        This method should be overridden in child classes.
 
384
        This method should be overriden in child classes.
476
385
        """
477
386
        compatible = True
478
387
        # different inv parent
494
403
        # first requested, or preload them if they're already known
495
404
        pass            # nothing to do by default
496
405
 
497
 
    def _forget_tree_state(self):
498
 
        pass
499
 
 
500
406
 
501
407
class RootEntry(InventoryEntry):
502
408
 
503
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
504
 
                 'text_id', 'parent_id', 'children', 'executable', 
505
 
                 'revision', 'symlink_target']
506
 
 
507
409
    def _check(self, checker, rev_id, tree):
508
410
        """See InventoryEntry._check"""
509
411
 
510
412
    def __init__(self, file_id):
511
413
        self.file_id = file_id
512
414
        self.children = {}
513
 
        self.kind = 'directory'
 
415
        self.kind = 'root_directory'
514
416
        self.parent_id = None
515
 
        self.name = u''
516
 
        self.revision = None
517
 
        warn('RootEntry is deprecated as of bzr 0.10.  Please use '
518
 
             'InventoryDirectory instead.',
519
 
            DeprecationWarning, stacklevel=2)
 
417
        self.name = ''
520
418
 
521
419
    def __eq__(self, other):
522
420
        if not isinstance(other, RootEntry):
529
427
class InventoryDirectory(InventoryEntry):
530
428
    """A directory in an inventory."""
531
429
 
532
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
533
 
                 'text_id', 'parent_id', 'children', 'executable', 
534
 
                 'revision', 'symlink_target']
535
 
 
536
430
    def _check(self, checker, rev_id, tree):
537
431
        """See InventoryEntry._check"""
538
 
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
 
432
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
539
433
            raise BzrCheckError('directory {%s} has text in revision {%s}'
540
434
                                % (self.file_id, rev_id))
541
435
 
568
462
        """See InventoryEntry._put_on_disk."""
569
463
        os.mkdir(fullpath)
570
464
 
571
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
572
 
        """See InventoryEntry._snapshot_text."""
573
 
        commit_builder.modified_directory(self.file_id, file_parents)
574
 
 
575
465
 
576
466
class InventoryFile(InventoryEntry):
577
467
    """A file in an inventory."""
578
468
 
579
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
580
 
                 'text_id', 'parent_id', 'children', 'executable', 
581
 
                 'revision', 'symlink_target']
582
 
 
583
 
    def _check(self, checker, tree_revision_id, tree):
 
469
    def _check(self, checker, rev_id, tree):
584
470
        """See InventoryEntry._check"""
585
 
        t = (self.file_id, self.revision)
 
471
        revision = self.revision
 
472
        t = (self.file_id, revision)
586
473
        if t in checker.checked_texts:
587
 
            prev_sha = checker.checked_texts[t]
 
474
            prev_sha = checker.checked_texts[t] 
588
475
            if prev_sha != self.text_sha1:
589
476
                raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
590
 
                                    (self.file_id, tree_revision_id))
 
477
                                    (self.file_id, rev_id))
591
478
            else:
592
479
                checker.repeated_text_cnt += 1
593
480
                return
594
 
 
595
 
        if self.file_id not in checker.checked_weaves:
596
 
            mutter('check weave {%s}', self.file_id)
597
 
            w = tree.get_weave(self.file_id)
598
 
            # Not passing a progress bar, because it creates a new
599
 
            # progress, which overwrites the current progress,
600
 
            # and doesn't look nice
601
 
            w.check()
602
 
            checker.checked_weaves[self.file_id] = True
603
 
        else:
604
 
            w = tree.get_weave(self.file_id)
605
 
 
606
 
        mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)
607
 
        checker.checked_text_cnt += 1
608
 
        # We can't check the length, because Weave doesn't store that
609
 
        # information, and the whole point of looking at the weave's
610
 
        # sha1sum is that we don't have to extract the text.
611
 
        if self.text_sha1 != w.get_sha1(self.revision):
612
 
            raise BzrCheckError('text {%s} version {%s} wrong sha1' 
613
 
                                % (self.file_id, self.revision))
 
481
        mutter('check version {%s} of {%s}', rev_id, self.file_id)
 
482
        file_lines = tree.get_file_lines(self.file_id)
 
483
        checker.checked_text_cnt += 1 
 
484
        if self.text_size != sum(map(len, file_lines)):
 
485
            raise BzrCheckError('text {%s} wrong size' % self.text_id)
 
486
        if self.text_sha1 != sha_strings(file_lines):
 
487
            raise BzrCheckError('text {%s} wrong sha1' % self.text_id)
614
488
        checker.checked_texts[t] = self.text_sha1
615
489
 
616
490
    def copy(self):
624
498
 
625
499
    def detect_changes(self, old_entry):
626
500
        """See InventoryEntry.detect_changes."""
627
 
        assert self.text_sha1 is not None
628
 
        assert old_entry.text_sha1 is not None
 
501
        assert self.text_sha1 != None
 
502
        assert old_entry.text_sha1 != None
629
503
        text_modified = (self.text_sha1 != old_entry.text_sha1)
630
504
        meta_modified = (self.executable != old_entry.executable)
631
505
        return text_modified, meta_modified
633
507
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
634
508
             output_to, reverse=False):
635
509
        """See InventoryEntry._diff."""
636
 
        try:
637
 
            from_text = tree.get_file(self.file_id).readlines()
638
 
            if to_entry:
639
 
                to_text = to_tree.get_file(to_entry.file_id).readlines()
640
 
            else:
641
 
                to_text = []
642
 
            if not reverse:
643
 
                text_diff(from_label, from_text,
644
 
                          to_label, to_text, output_to)
645
 
            else:
646
 
                text_diff(to_label, to_text,
647
 
                          from_label, from_text, output_to)
648
 
        except BinaryFile:
649
 
            if reverse:
650
 
                label_pair = (to_label, from_label)
651
 
            else:
652
 
                label_pair = (from_label, to_label)
653
 
            print >> output_to, "Binary files %s and %s differ" % label_pair
 
510
        from_text = tree.get_file(self.file_id).readlines()
 
511
        if to_entry:
 
512
            to_text = to_tree.get_file(to_entry.file_id).readlines()
 
513
        else:
 
514
            to_text = []
 
515
        if not reverse:
 
516
            text_diff(from_label, from_text,
 
517
                      to_label, to_text, output_to)
 
518
        else:
 
519
            text_diff(to_label, to_text,
 
520
                      from_label, from_text, output_to)
654
521
 
655
522
    def has_text(self):
656
523
        """See InventoryEntry.has_text."""
683
550
 
684
551
    def _read_tree_state(self, path, work_tree):
685
552
        """See InventoryEntry._read_tree_state."""
686
 
        self.text_sha1 = work_tree.get_file_sha1(self.file_id, path=path)
687
 
        # FIXME: 20050930 probe for the text size when getting sha1
688
 
        # in _read_tree_state
689
 
        self.executable = work_tree.is_executable(self.file_id, path=path)
690
 
 
691
 
    def __repr__(self):
692
 
        return ("%s(%r, %r, parent_id=%r, sha1=%r, len=%s)"
693
 
                % (self.__class__.__name__,
694
 
                   self.file_id,
695
 
                   self.name,
696
 
                   self.parent_id,
697
 
                   self.text_sha1,
698
 
                   self.text_size))
699
 
 
700
 
    def _forget_tree_state(self):
701
 
        self.text_sha1 = None
702
 
 
703
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
 
553
        self.text_sha1 = work_tree.get_file_sha1(self.file_id)
 
554
        self.executable = work_tree.is_executable(self.file_id)
 
555
 
 
556
    def _snapshot_text(self, file_parents, work_tree, weave_store, transaction):
704
557
        """See InventoryEntry._snapshot_text."""
705
 
        def get_content_byte_lines():
706
 
            return work_tree.get_file(self.file_id).readlines()
707
 
        self.text_sha1, self.text_size = commit_builder.modified_file_text(
708
 
            self.file_id, file_parents, get_content_byte_lines, self.text_sha1, self.text_size)
 
558
        mutter('storing file {%s} in revision {%s}',
 
559
               self.file_id, self.revision)
 
560
        # special case to avoid diffing on renames or 
 
561
        # reparenting
 
562
        if (len(file_parents) == 1
 
563
            and self.text_sha1 == file_parents.values()[0].text_sha1
 
564
            and self.text_size == file_parents.values()[0].text_size):
 
565
            previous_ie = file_parents.values()[0]
 
566
            weave_store.add_identical_text(
 
567
                self.file_id, previous_ie.revision, 
 
568
                self.revision, file_parents, transaction)
 
569
        else:
 
570
            new_lines = work_tree.get_file(self.file_id).readlines()
 
571
            self._add_text_to_weave(new_lines, file_parents, weave_store,
 
572
                                    transaction)
 
573
            self.text_sha1 = sha_strings(new_lines)
 
574
            self.text_size = sum(map(len, new_lines))
 
575
 
709
576
 
710
577
    def _unchanged(self, previous_ie):
711
578
        """See InventoryEntry._unchanged."""
724
591
class InventoryLink(InventoryEntry):
725
592
    """A file in an inventory."""
726
593
 
727
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
728
 
                 'text_id', 'parent_id', 'children', 'executable', 
729
 
                 'revision', 'symlink_target']
 
594
    __slots__ = ['symlink_target']
730
595
 
731
596
    def _check(self, checker, rev_id, tree):
732
597
        """See InventoryEntry._check"""
733
 
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
 
598
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
734
599
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
735
600
                    % (self.file_id, rev_id))
736
 
        if self.symlink_target is None:
 
601
        if self.symlink_target == None:
737
602
            raise BzrCheckError('symlink {%s} has no target in revision {%s}'
738
603
                    % (self.file_id, rev_id))
739
604
 
779
644
 
780
645
    def _put_in_tar(self, item, tree):
781
646
        """See InventoryEntry._put_in_tar."""
782
 
        item.type = tarfile.SYMTYPE
 
647
        iterm.type = tarfile.SYMTYPE
783
648
        fileobj = None
784
649
        item.size = 0
785
650
        item.mode = 0755
797
662
        """See InventoryEntry._read_tree_state."""
798
663
        self.symlink_target = work_tree.get_symlink_target(self.file_id)
799
664
 
800
 
    def _forget_tree_state(self):
801
 
        self.symlink_target = None
802
 
 
803
665
    def _unchanged(self, previous_ie):
804
666
        """See InventoryEntry._unchanged."""
805
667
        compatible = super(InventoryLink, self)._unchanged(previous_ie)
807
669
            compatible = False
808
670
        return compatible
809
671
 
810
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
811
 
        """See InventoryEntry._snapshot_text."""
812
 
        commit_builder.modified_link(
813
 
            self.file_id, file_parents, self.symlink_target)
814
 
 
815
672
 
816
673
class Inventory(object):
817
674
    """Inventory of versioned files in a tree.
832
689
 
833
690
    >>> inv = Inventory()
834
691
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
835
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
692
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
836
693
    >>> inv['123-123'].name
837
694
    'hello.c'
838
695
 
846
703
    May also look up by name:
847
704
 
848
705
    >>> [x[0] for x in inv.iter_entries()]
849
 
    ['', u'hello.c']
 
706
    ['hello.c']
850
707
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
851
708
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
852
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678', sha1=None, len=None)
 
709
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
853
710
    """
854
 
    def __init__(self, root_id=ROOT_ID, revision_id=None):
 
711
    def __init__(self, root_id=ROOT_ID):
855
712
        """Create or read an inventory.
856
713
 
857
714
        If a working directory is specified, the inventory is read
861
718
        The inventory is created with a default root directory, with
862
719
        an id of None.
863
720
        """
864
 
        # We are letting Branch.create() create a unique inventory
 
721
        # We are letting Branch.initialize() create a unique inventory
865
722
        # root id. Rather than generating a random one here.
866
723
        #if root_id is None:
867
724
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
868
 
        self.root = InventoryDirectory(root_id, '', None)
869
 
        # FIXME: this isn't ever used, changing it to self.revision may break
870
 
        # things. TODO make everything use self.revision_id
871
 
        self.revision_id = revision_id
 
725
        self.root = RootEntry(root_id)
872
726
        self._byid = {self.root.file_id: self.root}
873
727
 
 
728
 
874
729
    def copy(self):
875
 
        # TODO: jam 20051218 Should copy also copy the revision_id?
876
 
        entries = self.iter_entries()
877
 
        other = Inventory(entries.next()[1].file_id)
 
730
        other = Inventory(self.root.file_id)
878
731
        # copy recursively so we know directories will be added before
879
732
        # their children.  There are more efficient ways than this...
880
 
        for path, entry in entries():
 
733
        for path, entry in self.iter_entries():
 
734
            if entry == self.root:
 
735
                continue
881
736
            other.add(entry.copy())
882
737
        return other
883
738
 
 
739
 
884
740
    def __iter__(self):
885
741
        return iter(self._byid)
886
742
 
 
743
 
887
744
    def __len__(self):
888
745
        """Returns number of entries."""
889
746
        return len(self._byid)
890
747
 
 
748
 
891
749
    def iter_entries(self, from_dir=None):
892
750
        """Return (path, entry) pairs, in order by name."""
893
 
        if from_dir is None:
894
 
            assert self.root
895
 
            from_dir = self.root
896
 
            yield '', self.root
897
 
        elif isinstance(from_dir, basestring):
898
 
            from_dir = self._byid[from_dir]
899
 
            
900
 
        # unrolling the recursive called changed the time from
901
 
        # 440ms/663ms (inline/total) to 116ms/116ms
902
 
        children = from_dir.children.items()
903
 
        children.sort()
904
 
        children = collections.deque(children)
905
 
        stack = [(u'', children)]
906
 
        while stack:
907
 
            from_dir_relpath, children = stack[-1]
908
 
 
909
 
            while children:
910
 
                name, ie = children.popleft()
911
 
 
912
 
                # we know that from_dir_relpath never ends in a slash
913
 
                # and 'f' doesn't begin with one, we can do a string op, rather
914
 
                # than the checks of pathjoin(), though this means that all paths
915
 
                # start with a slash
916
 
                path = from_dir_relpath + '/' + name
917
 
 
918
 
                yield path[1:], ie
919
 
 
920
 
                if ie.kind != 'directory':
921
 
                    continue
922
 
 
923
 
                # But do this child first
924
 
                new_children = ie.children.items()
925
 
                new_children.sort()
926
 
                new_children = collections.deque(new_children)
927
 
                stack.append((path, new_children))
928
 
                # Break out of inner loop, so that we start outer loop with child
929
 
                break
930
 
            else:
931
 
                # if we finished all children, pop it off the stack
932
 
                stack.pop()
933
 
 
934
 
    def iter_entries_by_dir(self, from_dir=None):
935
 
        """Iterate over the entries in a directory first order.
936
 
 
937
 
        This returns all entries for a directory before returning
938
 
        the entries for children of a directory. This is not
939
 
        lexicographically sorted order, and is a hybrid between
940
 
        depth-first and breadth-first.
941
 
 
942
 
        :return: This yields (path, entry) pairs
943
 
        """
944
 
        # TODO? Perhaps this should return the from_dir so that the root is
945
 
        # yielded? or maybe an option?
946
 
        if from_dir is None:
947
 
            assert self.root
948
 
            from_dir = self.root
949
 
            yield '', self.root
950
 
        elif isinstance(from_dir, basestring):
951
 
            from_dir = self._byid[from_dir]
952
 
            
953
 
        stack = [(u'', from_dir)]
954
 
        while stack:
955
 
            cur_relpath, cur_dir = stack.pop()
956
 
 
957
 
            child_dirs = []
958
 
            for child_name, child_ie in sorted(cur_dir.children.iteritems()):
959
 
 
960
 
                child_relpath = cur_relpath + child_name
961
 
 
962
 
                yield child_relpath, child_ie
963
 
 
964
 
                if child_ie.kind == 'directory':
965
 
                    child_dirs.append((child_relpath+'/', child_ie))
966
 
            stack.extend(reversed(child_dirs))
 
751
        if from_dir == None:
 
752
            assert self.root
 
753
            from_dir = self.root
 
754
        elif isinstance(from_dir, basestring):
 
755
            from_dir = self._byid[from_dir]
 
756
            
 
757
        kids = from_dir.children.items()
 
758
        kids.sort()
 
759
        for name, ie in kids:
 
760
            yield name, ie
 
761
            if ie.kind == 'directory':
 
762
                for cn, cie in self.iter_entries(from_dir=ie.file_id):
 
763
                    yield os.path.join(name, cn), cie
 
764
 
967
765
 
968
766
    def entries(self):
969
767
        """Return list of (path, ie) for all entries except the root.
975
773
            kids = dir_ie.children.items()
976
774
            kids.sort()
977
775
            for name, ie in kids:
978
 
                child_path = pathjoin(dir_path, name)
 
776
                child_path = os.path.join(dir_path, name)
979
777
                accum.append((child_path, ie))
980
778
                if ie.kind == 'directory':
981
779
                    descend(ie, child_path)
982
780
 
983
 
        descend(self.root, u'')
 
781
        descend(self.root, '')
984
782
        return accum
985
783
 
 
784
 
986
785
    def directories(self):
987
786
        """Return (path, entry) pairs for all directories, including the root.
988
787
        """
994
793
            kids.sort()
995
794
 
996
795
            for name, child_ie in kids:
997
 
                child_path = pathjoin(parent_path, name)
 
796
                child_path = os.path.join(parent_path, name)
998
797
                descend(child_ie, child_path)
999
 
        descend(self.root, u'')
 
798
        descend(self.root, '')
1000
799
        return accum
1001
800
        
 
801
 
 
802
 
1002
803
    def __contains__(self, file_id):
1003
804
        """True if this entry contains a file with given id.
1004
805
 
1005
806
        >>> inv = Inventory()
1006
807
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1007
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
808
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
1008
809
        >>> '123' in inv
1009
810
        True
1010
811
        >>> '456' in inv
1012
813
        """
1013
814
        return file_id in self._byid
1014
815
 
 
816
 
1015
817
    def __getitem__(self, file_id):
1016
818
        """Return the entry for given file_id.
1017
819
 
1018
820
        >>> inv = Inventory()
1019
821
        >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
1020
 
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
822
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
1021
823
        >>> inv['123123'].name
1022
824
        'hello.c'
1023
825
        """
1024
826
        try:
1025
827
            return self._byid[file_id]
1026
828
        except KeyError:
1027
 
            if file_id is None:
 
829
            if file_id == None:
1028
830
                raise BzrError("can't look up file_id None")
1029
831
            else:
1030
832
                raise BzrError("file_id {%s} not in inventory" % file_id)
1031
833
 
 
834
 
1032
835
    def get_file_kind(self, file_id):
1033
836
        return self._byid[file_id].kind
1034
837
 
1035
838
    def get_child(self, parent_id, filename):
1036
839
        return self[parent_id].children.get(filename)
1037
840
 
 
841
 
1038
842
    def add(self, entry):
1039
843
        """Add entry to inventory.
1040
844
 
1054
858
        except KeyError:
1055
859
            raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
1056
860
 
1057
 
        if entry.name in parent.children:
 
861
        if parent.children.has_key(entry.name):
1058
862
            raise BzrError("%s is already versioned" %
1059
 
                    pathjoin(self.id2path(parent.file_id), entry.name))
 
863
                    appendpath(self.id2path(parent.file_id), entry.name))
1060
864
 
1061
865
        self._byid[entry.file_id] = entry
1062
866
        parent.children[entry.name] = entry
1063
867
        return entry
1064
868
 
1065
 
    def add_path(self, relpath, kind, file_id=None, parent_id=None):
 
869
 
 
870
    def add_path(self, relpath, kind, file_id=None):
1066
871
        """Add entry from a path.
1067
872
 
1068
873
        The immediate parent must already be versioned.
1069
874
 
1070
875
        Returns the new entry object."""
 
876
        from bzrlib.branch import gen_file_id
1071
877
        
1072
 
        parts = osutils.splitpath(relpath)
1073
 
 
 
878
        parts = bzrlib.osutils.splitpath(relpath)
1074
879
        if len(parts) == 0:
1075
 
            if file_id is None:
1076
 
                file_id = bzrlib.workingtree.gen_root_id()
1077
 
            self.root = InventoryDirectory(file_id, '', None)
1078
 
            self._byid = {self.root.file_id: self.root}
1079
 
            return
 
880
            raise BzrError("cannot re-add root of inventory")
 
881
 
 
882
        if file_id == None:
 
883
            file_id = gen_file_id(relpath)
 
884
 
 
885
        parent_path = parts[:-1]
 
886
        parent_id = self.path2id(parent_path)
 
887
        if parent_id == None:
 
888
            raise NotVersionedError(parent_path)
 
889
 
 
890
        if kind == 'directory':
 
891
            ie = InventoryDirectory(file_id, parts[-1], parent_id)
 
892
        elif kind == 'file':
 
893
            ie = InventoryFile(file_id, parts[-1], parent_id)
 
894
        elif kind == 'symlink':
 
895
            ie = InventoryLink(file_id, parts[-1], parent_id)
1080
896
        else:
1081
 
            parent_path = parts[:-1]
1082
 
            parent_id = self.path2id(parent_path)
1083
 
            if parent_id is None:
1084
 
                raise NotVersionedError(path=parent_path)
1085
 
        ie = make_entry(kind, parts[-1], parent_id, file_id)
 
897
            raise BzrError("unknown kind %r" % kind)
1086
898
        return self.add(ie)
1087
899
 
 
900
 
1088
901
    def __delitem__(self, file_id):
1089
902
        """Remove entry by id.
1090
903
 
1091
904
        >>> inv = Inventory()
1092
905
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1093
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
906
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
1094
907
        >>> '123' in inv
1095
908
        True
1096
909
        >>> del inv['123']
1099
912
        """
1100
913
        ie = self[file_id]
1101
914
 
1102
 
        assert ie.parent_id is None or \
1103
 
            self[ie.parent_id].children[ie.name] == ie
 
915
        assert self[ie.parent_id].children[ie.name] == ie
1104
916
        
 
917
        # TODO: Test deleting all children; maybe hoist to a separate
 
918
        # deltree method?
 
919
        if ie.kind == 'directory':
 
920
            for cie in ie.children.values():
 
921
                del self[cie.file_id]
 
922
            del ie.children
 
923
 
1105
924
        del self._byid[file_id]
1106
 
        if ie.parent_id is not None:
1107
 
            del self[ie.parent_id].children[ie.name]
 
925
        del self[ie.parent_id].children[ie.name]
 
926
 
1108
927
 
1109
928
    def __eq__(self, other):
1110
929
        """Compare two sets by comparing their contents.
1114
933
        >>> i1 == i2
1115
934
        True
1116
935
        >>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
1117
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
 
936
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1118
937
        >>> i1 == i2
1119
938
        False
1120
939
        >>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
1121
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
 
940
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1122
941
        >>> i1 == i2
1123
942
        True
1124
943
        """
1125
944
        if not isinstance(other, Inventory):
1126
945
            return NotImplemented
1127
946
 
 
947
        if len(self._byid) != len(other._byid):
 
948
            # shortcut: obviously not the same
 
949
            return False
 
950
 
1128
951
        return self._byid == other._byid
1129
952
 
 
953
 
1130
954
    def __ne__(self, other):
1131
955
        return not self.__eq__(other)
1132
956
 
 
957
 
1133
958
    def __hash__(self):
1134
959
        raise ValueError('not hashable')
1135
960
 
1136
 
    def _iter_file_id_parents(self, file_id):
1137
 
        """Yield the parents of file_id up to the root."""
1138
 
        while file_id is not None:
1139
 
            try:
1140
 
                ie = self._byid[file_id]
1141
 
            except KeyError:
1142
 
                raise BzrError("file_id {%s} not found in inventory" % file_id)
1143
 
            yield ie
1144
 
            file_id = ie.parent_id
1145
961
 
1146
962
    def get_idpath(self, file_id):
1147
963
        """Return a list of file_ids for the path to an entry.
1152
968
        root directory as depth 1.
1153
969
        """
1154
970
        p = []
1155
 
        for parent in self._iter_file_id_parents(file_id):
1156
 
            p.insert(0, parent.file_id)
 
971
        while file_id != None:
 
972
            try:
 
973
                ie = self._byid[file_id]
 
974
            except KeyError:
 
975
                raise BzrError("file_id {%s} not found in inventory" % file_id)
 
976
            p.insert(0, ie.file_id)
 
977
            file_id = ie.parent_id
1157
978
        return p
1158
979
 
 
980
 
1159
981
    def id2path(self, file_id):
1160
 
        """Return as a string the path to file_id.
 
982
        """Return as a list the path to file_id.
1161
983
        
1162
984
        >>> i = Inventory()
1163
985
        >>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))
1164
986
        >>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))
1165
 
        >>> print i.id2path('foo-id')
 
987
        >>> print i.id2path('foo-id').replace(os.sep, '/')
1166
988
        src/foo.c
1167
989
        """
1168
990
        # get all names, skipping root
1169
 
        return '/'.join(reversed(
1170
 
            [parent.name for parent in 
1171
 
             self._iter_file_id_parents(file_id)][:-1]))
 
991
        p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
 
992
        return os.sep.join(p)
1172
993
            
 
994
 
 
995
 
1173
996
    def path2id(self, name):
1174
997
        """Walk down through directories to return entry of last component.
1175
998
 
1179
1002
        This returns the entry of the last component in the path,
1180
1003
        which may be either a file or a directory.
1181
1004
 
1182
 
        Returns None IFF the path is not found.
 
1005
        Returns None iff the path is not found.
1183
1006
        """
1184
1007
        if isinstance(name, types.StringTypes):
1185
1008
            name = splitpath(name)
1186
1009
 
1187
 
        # mutter("lookup path %r" % name)
 
1010
        mutter("lookup path %r" % name)
1188
1011
 
1189
1012
        parent = self.root
1190
1013
        for f in name:
1199
1022
 
1200
1023
        return parent.file_id
1201
1024
 
 
1025
 
1202
1026
    def has_filename(self, names):
1203
1027
        return bool(self.path2id(names))
1204
1028
 
 
1029
 
1205
1030
    def has_id(self, file_id):
1206
1031
        return self._byid.has_key(file_id)
1207
1032
 
 
1033
 
1208
1034
    def rename(self, file_id, new_parent_id, new_name):
1209
1035
        """Move a file within the inventory.
1210
1036
 
1235
1061
        file_ie.parent_id = new_parent_id
1236
1062
 
1237
1063
 
1238
 
def make_entry(kind, name, parent_id, file_id=None):
1239
 
    """Create an inventory entry.
1240
 
 
1241
 
    :param kind: the type of inventory entry to create.
1242
 
    :param name: the basename of the entry.
1243
 
    :param parent_id: the parent_id of the entry.
1244
 
    :param file_id: the file_id to use. if None, one will be created.
1245
 
    """
1246
 
    if file_id is None:
1247
 
        file_id = bzrlib.workingtree.gen_file_id(name)
1248
 
 
1249
 
    norm_name, can_access = osutils.normalized_filename(name)
1250
 
    if norm_name != name:
1251
 
        if can_access:
1252
 
            name = norm_name
1253
 
        else:
1254
 
            # TODO: jam 20060701 This would probably be more useful
1255
 
            #       if the error was raised with the full path
1256
 
            raise errors.InvalidNormalization(name)
1257
 
 
1258
 
    if kind == 'directory':
1259
 
        return InventoryDirectory(file_id, name, parent_id)
1260
 
    elif kind == 'file':
1261
 
        return InventoryFile(file_id, name, parent_id)
1262
 
    elif kind == 'symlink':
1263
 
        return InventoryLink(file_id, name, parent_id)
1264
 
    else:
1265
 
        raise BzrError("unknown kind %r" % kind)
1266
1064
 
1267
1065
 
1268
1066
_NAME_RE = None
1269
1067
 
1270
1068
def is_valid_name(name):
1271
1069
    global _NAME_RE
1272
 
    if _NAME_RE is None:
 
1070
    if _NAME_RE == None:
1273
1071
        _NAME_RE = re.compile(r'^[^/\\]+$')
1274
1072
        
1275
1073
    return bool(_NAME_RE.match(name))