~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Martin Pool
  • Date: 2005-05-17 06:56:16 UTC
  • Revision ID: mbp@sourcefrog.net-20050517065616-6f23381d6184a8aa
- add space for un-merged patches

Show diffs side-by-side

added added

removed removed

Lines of Context:
21
21
 
22
22
 
23
23
import sys, os.path, types, re
 
24
from sets import Set
 
25
 
 
26
try:
 
27
    from cElementTree import Element, ElementTree, SubElement
 
28
except ImportError:
 
29
    from elementtree.ElementTree import Element, ElementTree, SubElement
 
30
 
 
31
from xml import XMLMixin
 
32
from errors import bailout, BzrError, BzrCheckError
24
33
 
25
34
import bzrlib
26
 
from bzrlib.errors import BzrError, BzrCheckError
27
 
 
28
35
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
29
36
from bzrlib.trace import mutter
30
37
 
31
 
class InventoryEntry(object):
 
38
class InventoryEntry(XMLMixin):
32
39
    """Description of a versioned file.
33
40
 
34
41
    An InventoryEntry has the following fields, which are also
62
69
    >>> i.add(InventoryEntry('2323', 'bye.c', 'file', '123'))
63
70
    Traceback (most recent call last):
64
71
    ...
65
 
    BzrError: inventory already contains entry with id {2323}
 
72
    BzrError: ('inventory already contains entry with id {2323}', [])
66
73
    >>> i.add(InventoryEntry('2324', 'bye.c', 'file', '123'))
67
74
    >>> i.add(InventoryEntry('2325', 'wibble', 'directory', '123'))
68
75
    >>> i.path2id('src/wibble')
154
161
    
155
162
    def to_element(self):
156
163
        """Convert to XML element"""
157
 
        from bzrlib.xml import Element
158
 
        
159
164
        e = Element('entry')
160
165
 
161
166
        e.set('name', self.name)
206
211
 
207
212
    from_element = classmethod(from_element)
208
213
 
209
 
    def __eq__(self, other):
 
214
    def __cmp__(self, other):
 
215
        if self is other:
 
216
            return 0
210
217
        if not isinstance(other, InventoryEntry):
211
218
            return NotImplemented
212
219
 
213
 
        return (self.file_id == other.file_id) \
214
 
               and (self.name == other.name) \
215
 
               and (self.text_sha1 == other.text_sha1) \
216
 
               and (self.text_size == other.text_size) \
217
 
               and (self.text_id == other.text_id) \
218
 
               and (self.parent_id == other.parent_id) \
219
 
               and (self.kind == other.kind)
220
 
 
221
 
 
222
 
    def __ne__(self, other):
223
 
        return not (self == other)
224
 
 
225
 
    def __hash__(self):
226
 
        raise ValueError('not hashable')
 
220
        return cmp(self.file_id, other.file_id) \
 
221
               or cmp(self.name, other.name) \
 
222
               or cmp(self.text_sha1, other.text_sha1) \
 
223
               or cmp(self.text_size, other.text_size) \
 
224
               or cmp(self.text_id, other.text_id) \
 
225
               or cmp(self.parent_id, other.parent_id) \
 
226
               or cmp(self.kind, other.kind)
227
227
 
228
228
 
229
229
 
235
235
        self.parent_id = None
236
236
        self.name = ''
237
237
 
238
 
    def __eq__(self, other):
 
238
    def __cmp__(self, other):
 
239
        if self is other:
 
240
            return 0
239
241
        if not isinstance(other, RootEntry):
240
242
            return NotImplemented
241
 
        
242
 
        return (self.file_id == other.file_id) \
243
 
               and (self.children == other.children)
244
 
 
245
 
 
246
 
 
247
 
class Inventory(object):
 
243
        return cmp(self.file_id, other.file_id) \
 
244
               or cmp(self.children, other.children)
 
245
 
 
246
 
 
247
 
 
248
class Inventory(XMLMixin):
248
249
    """Inventory of versioned files in a tree.
249
250
 
250
251
    This describes which file_id is present at each point in the tree,
262
263
    inserted, other than through the Inventory API.
263
264
 
264
265
    >>> inv = Inventory()
 
266
    >>> inv.write_xml(sys.stdout)
 
267
    <inventory>
 
268
    </inventory>
265
269
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
266
270
    >>> inv['123-123'].name
267
271
    'hello.c'
277
281
 
278
282
    >>> [x[0] for x in inv.iter_entries()]
279
283
    ['hello.c']
 
284
    
 
285
    >>> inv.write_xml(sys.stdout)
 
286
    <inventory>
 
287
    <entry file_id="123-123" kind="file" name="hello.c" />
 
288
    </inventory>
 
289
 
280
290
    """
281
291
    def __init__(self):
282
292
        """Create or read an inventory.
316
326
            if ie.kind == 'directory':
317
327
                for cn, cie in self.iter_entries(from_dir=ie.file_id):
318
328
                    yield os.path.join(name, cn), cie
319
 
 
320
 
 
321
 
    def entries(self):
322
 
        """Return list of (path, ie) for all entries except the root.
323
 
 
324
 
        This may be faster than iter_entries.
 
329
                    
 
330
 
 
331
 
 
332
    def directories(self):
 
333
        """Return (path, entry) pairs for all directories.
325
334
        """
326
 
        accum = []
327
 
        def descend(dir_ie, dir_path):
328
 
            kids = dir_ie.children.items()
329
 
            kids.sort()
330
 
            for name, ie in kids:
331
 
                child_path = os.path.join(dir_path, name)
332
 
                accum.append((child_path, ie))
 
335
        def descend(parent_ie):
 
336
            parent_name = parent_ie.name
 
337
            yield parent_name, parent_ie
 
338
 
 
339
            # directory children in sorted order
 
340
            dn = []
 
341
            for ie in parent_ie.children.itervalues():
333
342
                if ie.kind == 'directory':
334
 
                    descend(ie, child_path)
335
 
 
336
 
        descend(self.root, '')
337
 
        return accum
338
 
 
339
 
 
340
 
    def directories(self):
341
 
        """Return (path, entry) pairs for all directories, including the root.
342
 
        """
343
 
        accum = []
344
 
        def descend(parent_ie, parent_path):
345
 
            accum.append((parent_path, parent_ie))
 
343
                    dn.append((ie.name, ie))
 
344
            dn.sort()
346
345
            
347
 
            kids = [(ie.name, ie) for ie in parent_ie.children.itervalues() if ie.kind == 'directory']
348
 
            kids.sort()
 
346
            for name, child_ie in dn:
 
347
                for sub_name, sub_ie in descend(child_ie):
 
348
                    yield appendpath(parent_name, sub_name), sub_ie
349
349
 
350
 
            for name, child_ie in kids:
351
 
                child_path = os.path.join(parent_path, name)
352
 
                descend(child_ie, child_path)
353
 
        descend(self.root, '')
354
 
        return accum
 
350
        for name, ie in descend(self.root):
 
351
            yield name, ie
355
352
        
356
353
 
357
354
 
398
395
        To add  a file to a branch ready to be committed, use Branch.add,
399
396
        which calls this."""
400
397
        if entry.file_id in self._byid:
401
 
            raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
 
398
            bailout("inventory already contains entry with id {%s}" % entry.file_id)
402
399
 
403
400
        try:
404
401
            parent = self._byid[entry.parent_id]
405
402
        except KeyError:
406
 
            raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
 
403
            bailout("parent_id {%s} not in inventory" % entry.parent_id)
407
404
 
408
405
        if parent.children.has_key(entry.name):
409
 
            raise BzrError("%s is already versioned" %
 
406
            bailout("%s is already versioned" %
410
407
                    appendpath(self.id2path(parent.file_id), entry.name))
411
408
 
412
409
        self._byid[entry.file_id] = entry
417
414
        """Add entry from a path.
418
415
 
419
416
        The immediate parent must already be versioned"""
420
 
        from bzrlib.errors import NotVersionedError
421
 
        
422
417
        parts = bzrlib.osutils.splitpath(relpath)
423
418
        if len(parts) == 0:
424
 
            raise BzrError("cannot re-add root of inventory")
 
419
            bailout("cannot re-add root of inventory")
425
420
 
426
421
        if file_id == None:
427
 
            from bzrlib.branch import gen_file_id
428
 
            file_id = gen_file_id(relpath)
429
 
 
430
 
        parent_path = parts[:-1]
431
 
        parent_id = self.path2id(parent_path)
432
 
        if parent_id == None:
433
 
            raise NotVersionedError(parent_path)
434
 
 
 
422
            file_id = bzrlib.branch.gen_file_id(relpath)
 
423
 
 
424
        parent_id = self.path2id(parts[:-1])
 
425
        assert parent_id != None
435
426
        ie = InventoryEntry(file_id, parts[-1],
436
427
                            kind=kind, parent_id=parent_id)
437
428
        return self.add(ie)
463
454
        del self[ie.parent_id].children[ie.name]
464
455
 
465
456
 
 
457
    def id_set(self):
 
458
        return Set(self._byid)
 
459
 
 
460
 
466
461
    def to_element(self):
467
462
        """Convert to XML Element"""
468
 
        from bzrlib.xml import Element
469
 
        
470
463
        e = Element('inventory')
471
464
        e.text = '\n'
472
465
        for path, ie in self.iter_entries():
493
486
    from_element = classmethod(from_element)
494
487
 
495
488
 
496
 
    def __eq__(self, other):
 
489
    def __cmp__(self, other):
497
490
        """Compare two sets by comparing their contents.
498
491
 
499
492
        >>> i1 = Inventory()
507
500
        >>> i1 == i2
508
501
        True
509
502
        """
 
503
        if self is other:
 
504
            return 0
 
505
        
510
506
        if not isinstance(other, Inventory):
511
507
            return NotImplemented
512
508
 
513
 
        if len(self._byid) != len(other._byid):
514
 
            # shortcut: obviously not the same
515
 
            return False
516
 
 
517
 
        return self._byid == other._byid
518
 
 
519
 
 
520
 
    def __ne__(self, other):
521
 
        return not (self == other)
522
 
 
523
 
 
524
 
    def __hash__(self):
525
 
        raise ValueError('not hashable')
526
 
 
 
509
        if self.id_set() ^ other.id_set():
 
510
            return 1
 
511
 
 
512
        for file_id in self._byid:
 
513
            c = cmp(self[file_id], other[file_id])
 
514
            if c: return c
 
515
 
 
516
        return 0
527
517
 
528
518
 
529
519
    def get_idpath(self, file_id):
539
529
            try:
540
530
                ie = self._byid[file_id]
541
531
            except KeyError:
542
 
                raise BzrError("file_id {%s} not found in inventory" % file_id)
 
532
                bailout("file_id {%s} not found in inventory" % file_id)
543
533
            p.insert(0, ie.file_id)
544
534
            file_id = ie.parent_id
545
535
        return p
599
589
 
600
590
        This does not move the working file."""
601
591
        if not is_valid_name(new_name):
602
 
            raise BzrError("not an acceptable filename: %r" % new_name)
 
592
            bailout("not an acceptable filename: %r" % new_name)
603
593
 
604
594
        new_parent = self._byid[new_parent_id]
605
595
        if new_name in new_parent.children:
606
 
            raise BzrError("%r already exists in %r" % (new_name, self.id2path(new_parent_id)))
 
596
            bailout("%r already exists in %r" % (new_name, self.id2path(new_parent_id)))
607
597
 
608
598
        new_parent_idpath = self.get_idpath(new_parent_id)
609
599
        if file_id in new_parent_idpath:
610
 
            raise BzrError("cannot move directory %r into a subdirectory of itself, %r"
 
600
            bailout("cannot move directory %r into a subdirectory of itself, %r"
611
601
                    % (self.id2path(file_id), self.id2path(new_parent_id)))
612
602
 
613
603
        file_ie = self._byid[file_id]