~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Martin Pool
  • Date: 2005-07-22 18:49:46 UTC
  • Revision ID: mbp@sourcefrog.net-20050722184946-4bd334f8c0d75957
- separate out code that just scans the hash cache to find files that are possibly
  changed; don't actually re-read them unless the content has changed

Show diffs side-by-side

added added

removed removed

Lines of Context:
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
# TODO: Maybe also keep the full path of the entry, and the children?
19
 
# But those depend on its position within a particular inventory, and
20
 
# it would be nice not to need to hold the backpointer here.
21
 
 
22
 
# TODO: Perhaps split InventoryEntry into subclasses for files,
23
 
# directories, etc etc.
24
 
 
25
 
 
26
18
# This should really be an id randomly assigned when the tree is
27
19
# created, but it's not for now.
28
20
ROOT_ID = "TREE_ROOT"
35
27
 
36
28
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
37
29
from bzrlib.trace import mutter
38
 
from bzrlib.errors import NotVersionedError
39
 
        
40
30
 
41
31
class InventoryEntry(object):
42
32
    """Description of a versioned file.
44
34
    An InventoryEntry has the following fields, which are also
45
35
    present in the XML inventory-entry element:
46
36
 
47
 
    file_id
48
 
 
49
 
    name
50
 
        (within the parent directory)
51
 
 
52
 
    kind
53
 
        'directory' or 'file'
54
 
 
55
 
    parent_id
56
 
        file_id of the parent directory, or ROOT_ID
57
 
 
58
 
    entry_version
59
 
        the revision_id in which the name or parent of this file was
60
 
        last changed
61
 
 
62
 
    text_sha1
63
 
        sha-1 of the text of the file
64
 
        
65
 
    text_size
66
 
        size in bytes of the text of the file
67
 
        
68
 
    text_version
69
 
        the revision_id in which the text of this file was introduced
70
 
 
71
 
    (reading a version 4 tree created a text_id field.)
 
37
    * *file_id*
 
38
    * *name*: (only the basename within the directory, must not
 
39
      contain slashes)
 
40
    * *kind*: "directory" or "file"
 
41
    * *directory_id*: (if absent/null means the branch root directory)
 
42
    * *text_sha1*: only for files
 
43
    * *text_size*: in bytes, only for files 
 
44
    * *text_id*: identifier for the text version, only for files
 
45
 
 
46
    InventoryEntries can also exist inside a WorkingTree
 
47
    inventory, in which case they are not yet bound to a
 
48
    particular revision of the file.  In that case the text_sha1,
 
49
    text_size and text_id are absent.
 
50
 
72
51
 
73
52
    >>> i = Inventory()
74
53
    >>> i.path2id('')
75
54
    'TREE_ROOT'
76
55
    >>> i.add(InventoryEntry('123', 'src', 'directory', ROOT_ID))
77
 
    InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT')
78
56
    >>> i.add(InventoryEntry('2323', 'hello.c', 'file', parent_id='123'))
79
 
    InventoryEntry('2323', 'hello.c', kind='file', parent_id='123')
80
57
    >>> for j in i.iter_entries():
81
58
    ...   print j
82
59
    ... 
87
64
    ...
88
65
    BzrError: inventory already contains entry with id {2323}
89
66
    >>> i.add(InventoryEntry('2324', 'bye.c', 'file', '123'))
90
 
    InventoryEntry('2324', 'bye.c', kind='file', parent_id='123')
91
67
    >>> i.add(InventoryEntry('2325', 'wibble', 'directory', '123'))
92
 
    InventoryEntry('2325', 'wibble', kind='directory', parent_id='123')
93
68
    >>> i.path2id('src/wibble')
94
69
    '2325'
95
70
    >>> '2325' in i
96
71
    True
97
72
    >>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
98
 
    InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
99
73
    >>> i['2326']
100
74
    InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
101
75
    >>> for j in i.iter_entries():
109
83
    src/wibble/wibble.c
110
84
    >>> i.id2path('2326')
111
85
    'src/wibble/wibble.c'
 
86
 
 
87
    TODO: Maybe also keep the full path of the entry, and the children?
 
88
           But those depend on its position within a particular inventory, and
 
89
           it would be nice not to need to hold the backpointer here.
112
90
    """
 
91
 
 
92
    # TODO: split InventoryEntry into subclasses for files,
 
93
    # directories, etc etc.
 
94
 
 
95
    text_sha1 = None
 
96
    text_size = None
113
97
    
114
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
115
 
                 'text_id', 'parent_id', 'children',
116
 
                 'text_version', 'entry_version', ]
117
 
 
118
 
 
119
98
    def __init__(self, file_id, name, kind, parent_id, text_id=None):
120
99
        """Create an InventoryEntry
121
100
        
131
110
        Traceback (most recent call last):
132
111
        BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
133
112
        """
134
 
        assert isinstance(name, basestring), name
135
113
        if '/' in name or '\\' in name:
136
114
            raise BzrCheckError('InventoryEntry name %r is invalid' % name)
137
115
        
138
 
        self.text_version = None
139
 
        self.entry_version = None
140
 
        self.text_sha1 = None
141
 
        self.text_size = None
142
116
        self.file_id = file_id
143
117
        self.name = name
144
118
        self.kind = kind
161
135
 
162
136
    def copy(self):
163
137
        other = InventoryEntry(self.file_id, self.name, self.kind,
164
 
                               self.parent_id)
165
 
        other.text_id = self.text_id
 
138
                               self.parent_id, text_id=self.text_id)
166
139
        other.text_sha1 = self.text_sha1
167
140
        other.text_size = self.text_size
168
141
        # note that children are *not* copied; they're pulled across when
179
152
                   self.parent_id))
180
153
 
181
154
    
 
155
    def to_element(self):
 
156
        """Convert to XML element"""
 
157
        from bzrlib.xml import Element
 
158
        
 
159
        e = Element('entry')
 
160
 
 
161
        e.set('name', self.name)
 
162
        e.set('file_id', self.file_id)
 
163
        e.set('kind', self.kind)
 
164
 
 
165
        if self.text_size != None:
 
166
            e.set('text_size', '%d' % self.text_size)
 
167
            
 
168
        for f in ['text_id', 'text_sha1']:
 
169
            v = getattr(self, f)
 
170
            if v != None:
 
171
                e.set(f, v)
 
172
 
 
173
        # to be conservative, we don't externalize the root pointers
 
174
        # for now, leaving them as null in the xml form.  in a future
 
175
        # version it will be implied by nested elements.
 
176
        if self.parent_id != ROOT_ID:
 
177
            assert isinstance(self.parent_id, basestring)
 
178
            e.set('parent_id', self.parent_id)
 
179
 
 
180
        e.tail = '\n'
 
181
            
 
182
        return e
 
183
 
 
184
 
 
185
    def from_element(cls, elt):
 
186
        assert elt.tag == 'entry'
 
187
 
 
188
        ## original format inventories don't have a parent_id for
 
189
        ## nodes in the root directory, but it's cleaner to use one
 
190
        ## internally.
 
191
        parent_id = elt.get('parent_id')
 
192
        if parent_id == None:
 
193
            parent_id = ROOT_ID
 
194
 
 
195
        self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'), parent_id)
 
196
        self.text_id = elt.get('text_id')
 
197
        self.text_sha1 = elt.get('text_sha1')
 
198
        
 
199
        ## mutter("read inventoryentry: %r" % (elt.attrib))
 
200
 
 
201
        v = elt.get('text_size')
 
202
        self.text_size = v and int(v)
 
203
 
 
204
        return self
 
205
            
 
206
 
 
207
    from_element = classmethod(from_element)
 
208
 
182
209
    def __eq__(self, other):
183
210
        if not isinstance(other, InventoryEntry):
184
211
            return NotImplemented
189
216
               and (self.text_size == other.text_size) \
190
217
               and (self.text_id == other.text_id) \
191
218
               and (self.parent_id == other.parent_id) \
192
 
               and (self.kind == other.kind) \
193
 
               and (self.text_version == other.text_version) \
194
 
               and (self.entry_version == other.entry_version)
 
219
               and (self.kind == other.kind)
195
220
 
196
221
 
197
222
    def __ne__(self, other):
238
263
 
239
264
    >>> inv = Inventory()
240
265
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
241
 
    InventoryEntry('123-123', 'hello.c', kind='file', parent_id='TREE_ROOT')
242
266
    >>> inv['123-123'].name
243
267
    'hello.c'
244
268
 
255
279
    ['hello.c']
256
280
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
257
281
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
258
 
    InventoryEntry('123-123', 'hello.c', kind='file', parent_id='TREE_ROOT-12345678-12345678')
259
282
    """
260
283
    def __init__(self, root_id=ROOT_ID):
261
284
        """Create or read an inventory.
275
298
        self._byid = {self.root.file_id: self.root}
276
299
 
277
300
 
278
 
    def copy(self):
279
 
        other = Inventory(self.root.file_id)
280
 
        for entry in self._byid.itervalues():
281
 
            if entry == self.root:
282
 
                continue
283
 
            other.add(entry.copy())
284
 
        return other
285
 
 
286
 
 
287
301
    def __iter__(self):
288
302
        return iter(self._byid)
289
303
 
352
366
 
353
367
        >>> inv = Inventory()
354
368
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
355
 
        InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
356
369
        >>> '123' in inv
357
370
        True
358
371
        >>> '456' in inv
366
379
 
367
380
        >>> inv = Inventory()
368
381
        >>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
369
 
        InventoryEntry('123123', 'hello.c', kind='file', parent_id='TREE_ROOT')
370
382
        >>> inv['123123'].name
371
383
        'hello.c'
372
384
        """
390
402
        """Add entry to inventory.
391
403
 
392
404
        To add  a file to a branch ready to be committed, use Branch.add,
393
 
        which calls this.
394
 
 
395
 
        Returns the new entry object.
396
 
        """
 
405
        which calls this."""
397
406
        if entry.file_id in self._byid:
398
407
            raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
399
408
 
411
420
 
412
421
        self._byid[entry.file_id] = entry
413
422
        parent.children[entry.name] = entry
414
 
        return entry
415
423
 
416
424
 
417
425
    def add_path(self, relpath, kind, file_id=None):
418
426
        """Add entry from a path.
419
427
 
420
 
        The immediate parent must already be versioned.
421
 
 
422
 
        Returns the new entry object."""
423
 
        from bzrlib.branch import gen_file_id
 
428
        The immediate parent must already be versioned"""
 
429
        from bzrlib.errors import NotVersionedError
424
430
        
425
431
        parts = bzrlib.osutils.splitpath(relpath)
426
432
        if len(parts) == 0:
427
433
            raise BzrError("cannot re-add root of inventory")
428
434
 
429
435
        if file_id == None:
 
436
            from bzrlib.branch import gen_file_id
430
437
            file_id = gen_file_id(relpath)
431
438
 
432
439
        parent_path = parts[:-1]
444
451
 
445
452
        >>> inv = Inventory()
446
453
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
447
 
        InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
448
454
        >>> '123' in inv
449
455
        True
450
456
        >>> del inv['123']
466
472
        del self[ie.parent_id].children[ie.name]
467
473
 
468
474
 
 
475
    def to_element(self):
 
476
        """Convert to XML Element"""
 
477
        from bzrlib.xml import Element
 
478
        
 
479
        e = Element('inventory')
 
480
        e.text = '\n'
 
481
        if self.root.file_id not in (None, ROOT_ID):
 
482
            e.set('file_id', self.root.file_id)
 
483
        for path, ie in self.iter_entries():
 
484
            e.append(ie.to_element())
 
485
        return e
 
486
    
 
487
 
 
488
    def from_element(cls, elt):
 
489
        """Construct from XML Element
 
490
        
 
491
        >>> inv = Inventory()
 
492
        >>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c', 'file', ROOT_ID))
 
493
        >>> elt = inv.to_element()
 
494
        >>> inv2 = Inventory.from_element(elt)
 
495
        >>> inv2 == inv
 
496
        True
 
497
        """
 
498
        # XXXX: doctest doesn't run this properly under python2.3
 
499
        assert elt.tag == 'inventory'
 
500
        root_id = elt.get('file_id') or ROOT_ID
 
501
        o = cls(root_id)
 
502
        for e in elt:
 
503
            ie = InventoryEntry.from_element(e)
 
504
            if ie.parent_id == ROOT_ID:
 
505
                ie.parent_id = root_id
 
506
            o.add(ie)
 
507
        return o
 
508
        
 
509
    from_element = classmethod(from_element)
 
510
 
 
511
 
469
512
    def __eq__(self, other):
470
513
        """Compare two sets by comparing their contents.
471
514
 
474
517
        >>> i1 == i2
475
518
        True
476
519
        >>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
477
 
        InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
478
520
        >>> i1 == i2
479
521
        False
480
522
        >>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
481
 
        InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
482
523
        >>> i1 == i2
483
524
        True
484
525
        """
500
541
        raise ValueError('not hashable')
501
542
 
502
543
 
 
544
 
503
545
    def get_idpath(self, file_id):
504
546
        """Return a list of file_ids for the path to an entry.
505
547
 
598
640
 
599
641
 
600
642
 
601
 
_NAME_RE = None
 
643
_NAME_RE = re.compile(r'^[^/\\]+$')
602
644
 
603
645
def is_valid_name(name):
604
 
    global _NAME_RE
605
 
    if _NAME_RE == None:
606
 
        _NAME_RE = re.compile(r'^[^/\\]+$')
607
 
        
608
646
    return bool(_NAME_RE.match(name))