/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: mbp at sourcefrog
  • Date: 2005-03-29 01:26:19 UTC
  • Revision ID: mbp@sourcefrog.net-20050329012619-dd8959fc63b3a074
- fixup checks on retrieved files to cope with compression,
  and have less checks now there's a check command again

- move code to destroy stores into the ScratchStore subclass

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory.py
1
 
# (C) 2005 Canonical Ltd
 
1
#! /usr/bin/env python
 
2
# -*- coding: UTF-8 -*-
2
3
 
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
14
15
# along with this program; if not, write to the Free Software
15
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
17
 
 
18
 
# This should really be an id randomly assigned when the tree is
19
 
# created, but it's not for now.
20
 
ROOT_ID = "TREE_ROOT"
21
 
 
22
 
 
23
 
import sys, os.path, types, re
 
18
"""Inventories map files to their name in a revision."""
 
19
 
 
20
# TODO: Maybe store inventory_id in the file?  Not really needed.
 
21
 
 
22
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
 
23
__author__ = "Martin Pool <mbp@canonical.com>"
 
24
 
 
25
import sys, os.path, types
 
26
from sets import Set
 
27
 
 
28
try:
 
29
    from cElementTree import Element, ElementTree, SubElement
 
30
except ImportError:
 
31
    from elementtree.ElementTree import Element, ElementTree, SubElement
 
32
 
 
33
from xml import XMLMixin
 
34
from errors import bailout
24
35
 
25
36
import bzrlib
26
 
from bzrlib.errors import BzrError, BzrCheckError
27
 
 
28
37
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
29
38
from bzrlib.trace import mutter
30
 
from bzrlib.errors import NotVersionedError
31
 
        
32
39
 
33
 
class InventoryEntry(object):
 
40
class InventoryEntry(XMLMixin):
34
41
    """Description of a versioned file.
35
42
 
36
43
    An InventoryEntry has the following fields, which are also
53
60
 
54
61
    >>> i = Inventory()
55
62
    >>> i.path2id('')
56
 
    'TREE_ROOT'
57
 
    >>> i.add(InventoryEntry('123', 'src', 'directory', ROOT_ID))
58
 
    >>> i.add(InventoryEntry('2323', 'hello.c', 'file', parent_id='123'))
 
63
    >>> i.add(InventoryEntry('123', 'src', kind='directory'))
 
64
    >>> i.add(InventoryEntry('2323', 'hello.c', parent_id='123'))
59
65
    >>> for j in i.iter_entries():
60
66
    ...   print j
61
67
    ... 
62
 
    ('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
 
68
    ('src', InventoryEntry('123', 'src', kind='directory', parent_id=None))
63
69
    ('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
64
 
    >>> i.add(InventoryEntry('2323', 'bye.c', 'file', '123'))
 
70
    >>> i.add(InventoryEntry('2323', 'bye.c', parent_id='123'))
65
71
    Traceback (most recent call last):
66
72
    ...
67
 
    BzrError: inventory already contains entry with id {2323}
68
 
    >>> i.add(InventoryEntry('2324', 'bye.c', 'file', '123'))
69
 
    >>> i.add(InventoryEntry('2325', 'wibble', 'directory', '123'))
 
73
    BzrError: ('inventory already contains entry with id {2323}', [])
 
74
    >>> i.add(InventoryEntry('2324', 'bye.c', parent_id='123'))
 
75
    >>> i.add(InventoryEntry('2325', 'wibble', parent_id='123', kind='directory'))
70
76
    >>> i.path2id('src/wibble')
71
77
    '2325'
72
78
    >>> '2325' in i
73
79
    True
74
 
    >>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
 
80
    >>> i.add(InventoryEntry('2326', 'wibble.c', parent_id='2325'))
75
81
    >>> i['2326']
76
82
    InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
77
83
    >>> for j in i.iter_entries():
86
92
    >>> i.id2path('2326')
87
93
    'src/wibble/wibble.c'
88
94
 
89
 
    TODO: Maybe also keep the full path of the entry, and the children?
 
95
    :todo: Maybe also keep the full path of the entry, and the children?
90
96
           But those depend on its position within a particular inventory, and
91
97
           it would be nice not to need to hold the backpointer here.
92
98
    """
93
 
 
94
 
    # TODO: split InventoryEntry into subclasses for files,
95
 
    # directories, etc etc.
96
 
 
97
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
98
 
                 'text_id', 'parent_id', 'children', ]
99
 
 
100
 
    def __init__(self, file_id, name, kind, parent_id, text_id=None):
 
99
    def __init__(self, file_id, name, kind='file', text_id=None,
 
100
                 parent_id=None):
101
101
        """Create an InventoryEntry
102
102
        
103
103
        The filename must be a single component, relative to the
104
104
        parent directory; it cannot be a whole path or relative name.
105
105
 
106
 
        >>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
 
106
        >>> e = InventoryEntry('123', 'hello.c')
107
107
        >>> e.name
108
108
        'hello.c'
109
109
        >>> e.file_id
110
110
        '123'
111
 
        >>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
 
111
        >>> e = InventoryEntry('123', 'src/hello.c')
112
112
        Traceback (most recent call last):
113
 
        BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
 
113
        BzrError: ("InventoryEntry name is not a simple filename: 'src/hello.c'", [])
114
114
        """
115
 
        if '/' in name or '\\' in name:
116
 
            raise BzrCheckError('InventoryEntry name %r is invalid' % name)
117
 
        
118
 
        self.text_sha1 = None
119
 
        self.text_size = None
120
 
    
 
115
        
 
116
        if len(splitpath(name)) != 1:
 
117
            bailout('InventoryEntry name is not a simple filename: %r'
 
118
                    % name)
 
119
        
121
120
        self.file_id = file_id
122
121
        self.name = name
 
122
        assert kind in ['file', 'directory']
123
123
        self.kind = kind
124
124
        self.text_id = text_id
125
125
        self.parent_id = parent_id
126
 
        if kind == 'directory':
127
 
            self.children = {}
128
 
        elif kind == 'file':
129
 
            pass
130
 
        else:
131
 
            raise BzrError("unhandled entry kind %r" % kind)
132
 
 
133
 
 
134
 
 
135
 
    def sorted_children(self):
136
 
        l = self.children.items()
137
 
        l.sort()
138
 
        return l
 
126
        self.text_sha1 = None
 
127
        self.text_size = None
139
128
 
140
129
 
141
130
    def copy(self):
142
131
        other = InventoryEntry(self.file_id, self.name, self.kind,
143
 
                               self.parent_id, text_id=self.text_id)
 
132
                               self.text_id, self.parent_id)
144
133
        other.text_sha1 = self.text_sha1
145
134
        other.text_size = self.text_size
146
 
        # note that children are *not* copied; they're pulled across when
147
 
        # others are added
148
135
        return other
149
136
 
150
137
 
159
146
    
160
147
    def to_element(self):
161
148
        """Convert to XML element"""
162
 
        from bzrlib.xml import Element
163
 
        
164
149
        e = Element('entry')
165
150
 
166
151
        e.set('name', self.name)
167
152
        e.set('file_id', self.file_id)
168
153
        e.set('kind', self.kind)
169
154
 
170
 
        if self.text_size != None:
 
155
        if self.text_size is not None:
171
156
            e.set('text_size', '%d' % self.text_size)
172
157
            
173
 
        for f in ['text_id', 'text_sha1']:
 
158
        for f in ['text_id', 'text_sha1', 'parent_id']:
174
159
            v = getattr(self, f)
175
 
            if v != None:
 
160
            if v is not None:
176
161
                e.set(f, v)
177
162
 
178
 
        # to be conservative, we don't externalize the root pointers
179
 
        # for now, leaving them as null in the xml form.  in a future
180
 
        # version it will be implied by nested elements.
181
 
        if self.parent_id != ROOT_ID:
182
 
            assert isinstance(self.parent_id, basestring)
183
 
            e.set('parent_id', self.parent_id)
184
 
 
185
163
        e.tail = '\n'
186
164
            
187
165
        return e
189
167
 
190
168
    def from_element(cls, elt):
191
169
        assert elt.tag == 'entry'
192
 
 
193
 
        ## original format inventories don't have a parent_id for
194
 
        ## nodes in the root directory, but it's cleaner to use one
195
 
        ## internally.
196
 
        parent_id = elt.get('parent_id')
197
 
        if parent_id == None:
198
 
            parent_id = ROOT_ID
199
 
 
200
 
        self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'), parent_id)
 
170
        self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'))
201
171
        self.text_id = elt.get('text_id')
202
172
        self.text_sha1 = elt.get('text_sha1')
 
173
        self.parent_id = elt.get('parent_id')
203
174
        
204
175
        ## mutter("read inventoryentry: %r" % (elt.attrib))
205
176
 
211
182
 
212
183
    from_element = classmethod(from_element)
213
184
 
214
 
    def __eq__(self, other):
 
185
    def __cmp__(self, other):
 
186
        if self is other:
 
187
            return 0
215
188
        if not isinstance(other, InventoryEntry):
216
189
            return NotImplemented
217
190
 
218
 
        return (self.file_id == other.file_id) \
219
 
               and (self.name == other.name) \
220
 
               and (self.text_sha1 == other.text_sha1) \
221
 
               and (self.text_size == other.text_size) \
222
 
               and (self.text_id == other.text_id) \
223
 
               and (self.parent_id == other.parent_id) \
224
 
               and (self.kind == other.kind)
225
 
 
226
 
 
227
 
    def __ne__(self, other):
228
 
        return not (self == other)
229
 
 
230
 
    def __hash__(self):
231
 
        raise ValueError('not hashable')
232
 
 
233
 
 
234
 
 
235
 
class RootEntry(InventoryEntry):
236
 
    def __init__(self, file_id):
237
 
        self.file_id = file_id
238
 
        self.children = {}
239
 
        self.kind = 'root_directory'
240
 
        self.parent_id = None
241
 
        self.name = ''
242
 
 
243
 
    def __eq__(self, other):
244
 
        if not isinstance(other, RootEntry):
245
 
            return NotImplemented
246
 
        
247
 
        return (self.file_id == other.file_id) \
248
 
               and (self.children == other.children)
249
 
 
250
 
 
251
 
 
252
 
class Inventory(object):
 
191
        return cmp(self.file_id, other.file_id) \
 
192
               or cmp(self.name, other.name) \
 
193
               or cmp(self.text_sha1, other.text_sha1) \
 
194
               or cmp(self.text_size, other.text_size) \
 
195
               or cmp(self.text_id, other.text_id) \
 
196
               or cmp(self.parent_id, other.parent_id) \
 
197
               or cmp(self.kind, other.kind)
 
198
 
 
199
 
 
200
 
 
201
class Inventory(XMLMixin):
253
202
    """Inventory of versioned files in a tree.
254
203
 
255
 
    This describes which file_id is present at each point in the tree,
256
 
    and possibly the SHA-1 or other information about the file.
257
 
    Entries can be looked up either by path or by file_id.
 
204
    An Inventory acts like a set of InventoryEntry items.  You can
 
205
    also look files up by their file_id or name.
 
206
    
 
207
    May be read from and written to a metadata file in a tree.  To
 
208
    manipulate the inventory (for example to add a file), it is read
 
209
    in, modified, and then written back out.
258
210
 
259
211
    The inventory represents a typical unix file tree, with
260
212
    directories containing files and subdirectories.  We never store
264
216
    returned quickly.
265
217
 
266
218
    InventoryEntry objects must not be modified after they are
267
 
    inserted, other than through the Inventory API.
 
219
    inserted.
268
220
 
269
221
    >>> inv = Inventory()
270
 
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
 
222
    >>> inv.write_xml(sys.stdout)
 
223
    <inventory>
 
224
    </inventory>
 
225
    >>> inv.add(InventoryEntry('123-123', 'hello.c'))
271
226
    >>> inv['123-123'].name
272
227
    'hello.c'
 
228
    >>> for file_id in inv: print file_id
 
229
    ...
 
230
    123-123
273
231
 
274
232
    May be treated as an iterator or set to look up file ids:
275
233
    
282
240
 
283
241
    >>> [x[0] for x in inv.iter_entries()]
284
242
    ['hello.c']
285
 
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
286
 
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
 
243
    
 
244
    >>> inv.write_xml(sys.stdout)
 
245
    <inventory>
 
246
    <entry file_id="123-123" kind="file" name="hello.c" />
 
247
    </inventory>
 
248
 
287
249
    """
288
 
    def __init__(self, root_id=ROOT_ID):
 
250
 
 
251
    ## TODO: Clear up handling of files in subdirectories; we probably
 
252
    ## do want to be able to just look them up by name but this
 
253
    ## probably means gradually walking down the path, looking up as we go.
 
254
 
 
255
    ## TODO: Make sure only canonical filenames are stored.
 
256
 
 
257
    ## TODO: Do something sensible about the possible collisions on
 
258
    ## case-losing filesystems.  Perhaps we should just always forbid
 
259
    ## such collisions.
 
260
 
 
261
    ## _tree should probably just be stored as
 
262
    ## InventoryEntry._children on each directory.
 
263
 
 
264
    def __init__(self):
289
265
        """Create or read an inventory.
290
266
 
291
267
        If a working directory is specified, the inventory is read
292
268
        from there.  If the file is specified, read from that. If not,
293
269
        the inventory is created empty.
294
 
 
295
 
        The inventory is created with a default root directory, with
296
 
        an id of None.
297
270
        """
298
 
        # We are letting Branch(init=True) create a unique inventory
299
 
        # root id. Rather than generating a random one here.
300
 
        #if root_id is None:
301
 
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
302
 
        self.root = RootEntry(root_id)
303
 
        self._byid = {self.root.file_id: self.root}
 
271
        self._byid = dict()
 
272
 
 
273
        # _tree is indexed by parent_id; at each level a map from name
 
274
        # to ie.  The None entry is the root.
 
275
        self._tree = {None: {}}
304
276
 
305
277
 
306
278
    def __iter__(self):
312
284
        return len(self._byid)
313
285
 
314
286
 
315
 
    def iter_entries(self, from_dir=None):
 
287
    def iter_entries(self, parent_id=None):
316
288
        """Return (path, entry) pairs, in order by name."""
317
 
        if from_dir == None:
318
 
            assert self.root
319
 
            from_dir = self.root
320
 
        elif isinstance(from_dir, basestring):
321
 
            from_dir = self._byid[from_dir]
322
 
            
323
 
        kids = from_dir.children.items()
 
289
        kids = self._tree[parent_id].items()
324
290
        kids.sort()
325
291
        for name, ie in kids:
326
292
            yield name, ie
327
293
            if ie.kind == 'directory':
328
 
                for cn, cie in self.iter_entries(from_dir=ie.file_id):
329
 
                    yield os.path.join(name, cn), cie
330
 
 
331
 
 
332
 
    def entries(self):
333
 
        """Return list of (path, ie) for all entries except the root.
334
 
 
335
 
        This may be faster than iter_entries.
336
 
        """
337
 
        accum = []
338
 
        def descend(dir_ie, dir_path):
339
 
            kids = dir_ie.children.items()
340
 
            kids.sort()
341
 
            for name, ie in kids:
342
 
                child_path = os.path.join(dir_path, name)
343
 
                accum.append((child_path, ie))
344
 
                if ie.kind == 'directory':
345
 
                    descend(ie, child_path)
346
 
 
347
 
        descend(self.root, '')
348
 
        return accum
349
 
 
350
 
 
351
 
    def directories(self):
352
 
        """Return (path, entry) pairs for all directories, including the root.
353
 
        """
354
 
        accum = []
355
 
        def descend(parent_ie, parent_path):
356
 
            accum.append((parent_path, parent_ie))
357
 
            
358
 
            kids = [(ie.name, ie) for ie in parent_ie.children.itervalues() if ie.kind == 'directory']
359
 
            kids.sort()
360
 
 
361
 
            for name, child_ie in kids:
362
 
                child_path = os.path.join(parent_path, name)
363
 
                descend(child_ie, child_path)
364
 
        descend(self.root, '')
365
 
        return accum
 
294
                for cn, cie in self.iter_entries(parent_id=ie.file_id):
 
295
                    yield joinpath([name, cn]), cie
 
296
 
 
297
 
 
298
    def directories(self, include_root=True):
 
299
        """Return (path, entry) pairs for all directories.
 
300
        """
 
301
        if include_root:
 
302
            yield '', None
 
303
        for path, entry in self.iter_entries():
 
304
            if entry.kind == 'directory':
 
305
                yield path, entry
366
306
        
367
307
 
368
308
 
 
309
    def children(self, parent_id):
 
310
        """Return entries that are direct children of parent_id."""
 
311
        return self._tree[parent_id]
 
312
                    
 
313
 
 
314
 
 
315
    # TODO: return all paths and entries
 
316
 
 
317
 
369
318
    def __contains__(self, file_id):
370
319
        """True if this entry contains a file with given id.
371
320
 
372
321
        >>> inv = Inventory()
373
 
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
 
322
        >>> inv.add(InventoryEntry('123', 'foo.c'))
374
323
        >>> '123' in inv
375
324
        True
376
325
        >>> '456' in inv
383
332
        """Return the entry for given file_id.
384
333
 
385
334
        >>> inv = Inventory()
386
 
        >>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
 
335
        >>> inv.add(InventoryEntry('123123', 'hello.c'))
387
336
        >>> inv['123123'].name
388
337
        'hello.c'
389
338
        """
390
 
        try:
391
 
            return self._byid[file_id]
392
 
        except KeyError:
393
 
            if file_id == None:
394
 
                raise BzrError("can't look up file_id None")
395
 
            else:
396
 
                raise BzrError("file_id {%s} not in inventory" % file_id)
397
 
 
398
 
 
399
 
    def get_file_kind(self, file_id):
400
 
        return self._byid[file_id].kind
401
 
 
402
 
    def get_child(self, parent_id, filename):
403
 
        return self[parent_id].children.get(filename)
 
339
        return self._byid[file_id]
404
340
 
405
341
 
406
342
    def add(self, entry):
408
344
 
409
345
        To add  a file to a branch ready to be committed, use Branch.add,
410
346
        which calls this."""
411
 
        if entry.file_id in self._byid:
412
 
            raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
413
 
 
414
 
        if entry.parent_id == ROOT_ID or entry.parent_id is None:
415
 
            entry.parent_id = self.root.file_id
416
 
 
417
 
        try:
418
 
            parent = self._byid[entry.parent_id]
419
 
        except KeyError:
420
 
            raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
421
 
 
422
 
        if parent.children.has_key(entry.name):
423
 
            raise BzrError("%s is already versioned" %
424
 
                    appendpath(self.id2path(parent.file_id), entry.name))
 
347
        if entry.file_id in self:
 
348
            bailout("inventory already contains entry with id {%s}" % entry.file_id)
 
349
 
 
350
        if entry.parent_id != None:
 
351
            if entry.parent_id not in self:
 
352
                bailout("parent_id %s of new entry not found in inventory"
 
353
                        % entry.parent_id)
 
354
            
 
355
        if self._tree[entry.parent_id].has_key(entry.name):
 
356
            bailout("%s is already versioned"
 
357
                    % appendpath(self.id2path(entry.parent_id), entry.name))
425
358
 
426
359
        self._byid[entry.file_id] = entry
427
 
        parent.children[entry.name] = entry
 
360
        self._tree[entry.parent_id][entry.name] = entry
 
361
 
 
362
        if entry.kind == 'directory':
 
363
            self._tree[entry.file_id] = {}
428
364
 
429
365
 
430
366
    def add_path(self, relpath, kind, file_id=None):
431
367
        """Add entry from a path.
432
368
 
433
369
        The immediate parent must already be versioned"""
434
 
        from bzrlib.branch import gen_file_id
435
 
        
436
370
        parts = bzrlib.osutils.splitpath(relpath)
437
371
        if len(parts) == 0:
438
 
            raise BzrError("cannot re-add root of inventory")
439
 
 
440
 
        if file_id == None:
441
 
            file_id = gen_file_id(relpath)
442
 
 
443
 
        parent_path = parts[:-1]
444
 
        parent_id = self.path2id(parent_path)
445
 
        if parent_id == None:
446
 
            raise NotVersionedError(parent_path)
447
 
 
 
372
            bailout("cannot re-add root of inventory")
 
373
 
 
374
        if file_id is None:
 
375
            file_id = bzrlib.branch.gen_file_id(relpath)
 
376
 
 
377
        parent_id = self.path2id(parts[:-1])
448
378
        ie = InventoryEntry(file_id, parts[-1],
449
379
                            kind=kind, parent_id=parent_id)
450
380
        return self.add(ie)
454
384
        """Remove entry by id.
455
385
 
456
386
        >>> inv = Inventory()
457
 
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
 
387
        >>> inv.add(InventoryEntry('123', 'foo.c'))
458
388
        >>> '123' in inv
459
389
        True
460
390
        >>> del inv['123']
463
393
        """
464
394
        ie = self[file_id]
465
395
 
466
 
        assert self[ie.parent_id].children[ie.name] == ie
 
396
        assert self._tree[ie.parent_id][ie.name] == ie
467
397
        
468
398
        # TODO: Test deleting all children; maybe hoist to a separate
469
399
        # deltree method?
470
400
        if ie.kind == 'directory':
471
 
            for cie in ie.children.values():
 
401
            for cie in self._tree[file_id].values():
472
402
                del self[cie.file_id]
473
 
            del ie.children
 
403
            del self._tree[file_id]
474
404
 
475
405
        del self._byid[file_id]
476
 
        del self[ie.parent_id].children[ie.name]
 
406
        del self._tree[ie.parent_id][ie.name]
 
407
 
 
408
 
 
409
    def id_set(self):
 
410
        return Set(self._byid)
477
411
 
478
412
 
479
413
    def to_element(self):
480
414
        """Convert to XML Element"""
481
 
        from bzrlib.xml import Element
482
 
        
483
415
        e = Element('inventory')
484
416
        e.text = '\n'
485
 
        if self.root.file_id not in (None, ROOT_ID):
486
 
            e.set('file_id', self.root.file_id)
487
417
        for path, ie in self.iter_entries():
488
418
            e.append(ie.to_element())
489
419
        return e
491
421
 
492
422
    def from_element(cls, elt):
493
423
        """Construct from XML Element
494
 
        
 
424
 
495
425
        >>> inv = Inventory()
496
 
        >>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c', 'file', ROOT_ID))
 
426
        >>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c'))
497
427
        >>> elt = inv.to_element()
498
428
        >>> inv2 = Inventory.from_element(elt)
499
429
        >>> inv2 == inv
500
430
        True
501
431
        """
502
 
        # XXXX: doctest doesn't run this properly under python2.3
503
432
        assert elt.tag == 'inventory'
504
 
        root_id = elt.get('file_id') or ROOT_ID
505
 
        o = cls(root_id)
 
433
        o = cls()
506
434
        for e in elt:
507
 
            ie = InventoryEntry.from_element(e)
508
 
            if ie.parent_id == ROOT_ID:
509
 
                ie.parent_id = root_id
510
 
            o.add(ie)
 
435
            o.add(InventoryEntry.from_element(e))
511
436
        return o
512
437
        
513
438
    from_element = classmethod(from_element)
514
439
 
515
440
 
516
 
    def __eq__(self, other):
 
441
    def __cmp__(self, other):
517
442
        """Compare two sets by comparing their contents.
518
443
 
519
444
        >>> i1 = Inventory()
520
445
        >>> i2 = Inventory()
521
446
        >>> i1 == i2
522
447
        True
523
 
        >>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
 
448
        >>> i1.add(InventoryEntry('123', 'foo'))
524
449
        >>> i1 == i2
525
450
        False
526
 
        >>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
 
451
        >>> i2.add(InventoryEntry('123', 'foo'))
527
452
        >>> i1 == i2
528
453
        True
529
454
        """
 
455
        if self is other:
 
456
            return 0
 
457
        
530
458
        if not isinstance(other, Inventory):
531
459
            return NotImplemented
532
460
 
533
 
        if len(self._byid) != len(other._byid):
534
 
            # shortcut: obviously not the same
535
 
            return False
536
 
 
537
 
        return self._byid == other._byid
538
 
 
539
 
 
540
 
    def __ne__(self, other):
541
 
        return not (self == other)
542
 
 
543
 
 
544
 
    def __hash__(self):
545
 
        raise ValueError('not hashable')
546
 
 
547
 
 
548
 
 
549
 
    def get_idpath(self, file_id):
550
 
        """Return a list of file_ids for the path to an entry.
551
 
 
552
 
        The list contains one element for each directory followed by
553
 
        the id of the file itself.  So the length of the returned list
554
 
        is equal to the depth of the file in the tree, counting the
555
 
        root directory as depth 1.
556
 
        """
 
461
        if self.id_set() ^ other.id_set():
 
462
            return 1
 
463
 
 
464
        for file_id in self._byid:
 
465
            c = cmp(self[file_id], other[file_id])
 
466
            if c: return c
 
467
 
 
468
        return 0
 
469
 
 
470
 
 
471
    def id2path(self, file_id):
 
472
        """Return as a list the path to file_id."""
557
473
        p = []
558
474
        while file_id != None:
559
 
            try:
560
 
                ie = self._byid[file_id]
561
 
            except KeyError:
562
 
                raise BzrError("file_id {%s} not found in inventory" % file_id)
563
 
            p.insert(0, ie.file_id)
 
475
            ie = self[file_id]
 
476
            p = [ie.name] + p
564
477
            file_id = ie.parent_id
565
 
        return p
566
 
 
567
 
 
568
 
    def id2path(self, file_id):
569
 
        """Return as a list the path to file_id."""
570
 
 
571
 
        # get all names, skipping root
572
 
        p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
573
 
        return os.sep.join(p)
 
478
        return joinpath(p)
574
479
            
575
480
 
576
481
 
582
487
 
583
488
        This returns the entry of the last component in the path,
584
489
        which may be either a file or a directory.
585
 
 
586
 
        Returns None iff the path is not found.
587
490
        """
588
491
        if isinstance(name, types.StringTypes):
589
492
            name = splitpath(name)
590
493
 
591
 
        mutter("lookup path %r" % name)
592
 
 
593
 
        parent = self.root
 
494
        parent_id = None
594
495
        for f in name:
595
496
            try:
596
 
                cie = parent.children[f]
 
497
                cie = self._tree[parent_id][f]
597
498
                assert cie.name == f
598
 
                assert cie.parent_id == parent.file_id
599
 
                parent = cie
 
499
                parent_id = cie.file_id
600
500
            except KeyError:
601
501
                # or raise an error?
602
502
                return None
603
503
 
604
 
        return parent.file_id
 
504
        return parent_id
 
505
 
 
506
 
 
507
    def get_child(self, parent_id, child_name):
 
508
        return self._tree[parent_id].get(child_name)
605
509
 
606
510
 
607
511
    def has_filename(self, names):
609
513
 
610
514
 
611
515
    def has_id(self, file_id):
 
516
        assert isinstance(file_id, str)
612
517
        return self._byid.has_key(file_id)
613
518
 
614
519
 
615
 
    def rename(self, file_id, new_parent_id, new_name):
616
 
        """Move a file within the inventory.
617
 
 
618
 
        This can change either the name, or the parent, or both.
619
 
 
620
 
        This does not move the working file."""
621
 
        if not is_valid_name(new_name):
622
 
            raise BzrError("not an acceptable filename: %r" % new_name)
623
 
 
624
 
        new_parent = self._byid[new_parent_id]
625
 
        if new_name in new_parent.children:
626
 
            raise BzrError("%r already exists in %r" % (new_name, self.id2path(new_parent_id)))
627
 
 
628
 
        new_parent_idpath = self.get_idpath(new_parent_id)
629
 
        if file_id in new_parent_idpath:
630
 
            raise BzrError("cannot move directory %r into a subdirectory of itself, %r"
631
 
                    % (self.id2path(file_id), self.id2path(new_parent_id)))
632
 
 
633
 
        file_ie = self._byid[file_id]
634
 
        old_parent = self._byid[file_ie.parent_id]
635
 
 
636
 
        # TODO: Don't leave things messed up if this fails
637
 
 
638
 
        del old_parent.children[file_ie.name]
639
 
        new_parent.children[new_name] = file_ie
640
 
        
641
 
        file_ie.name = new_name
642
 
        file_ie.parent_id = new_parent_id
643
 
 
644
 
 
645
 
 
646
 
 
647
 
_NAME_RE = re.compile(r'^[^/\\]+$')
648
 
 
649
 
def is_valid_name(name):
650
 
    return bool(_NAME_RE.match(name))
 
520
 
 
521
 
 
522
 
 
523
if __name__ == '__main__':
 
524
    import doctest, inventory
 
525
    doctest.testmod(inventory)