/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-30 23:34:24 UTC
  • Revision ID: mbp@sourcefrog.net-20050330233424-68269ee36902dd19
experimental nested-inventory load support

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory.py
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
 
 
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
 
17
"""Inventories map files to their name in a revision."""
 
18
 
 
19
# TODO: Maybe store inventory_id in the file?  Not really needed.
 
20
 
 
21
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
 
22
__author__ = "Martin Pool <mbp@canonical.com>"
 
23
 
 
24
import sys, os.path, types
 
25
from sets import Set
 
26
 
 
27
try:
 
28
    from cElementTree import Element, ElementTree, SubElement
 
29
except ImportError:
 
30
    from elementtree.ElementTree import Element, ElementTree, SubElement
 
31
 
 
32
from xml import XMLMixin
 
33
from errors import bailout
24
34
 
25
35
import bzrlib
26
 
from bzrlib.errors import BzrError, BzrCheckError
27
 
 
28
36
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
29
37
from bzrlib.trace import mutter
30
 
from bzrlib.errors import NotVersionedError
31
 
        
32
38
 
33
 
class InventoryEntry(object):
 
39
class InventoryEntry(XMLMixin):
34
40
    """Description of a versioned file.
35
41
 
36
42
    An InventoryEntry has the following fields, which are also
53
59
 
54
60
    >>> i = Inventory()
55
61
    >>> 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'))
 
62
    >>> i.add(InventoryEntry('123', 'src', kind='directory'))
 
63
    >>> i.add(InventoryEntry('2323', 'hello.c', parent_id='123'))
59
64
    >>> for j in i.iter_entries():
60
65
    ...   print j
61
66
    ... 
62
 
    ('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
 
67
    ('src', InventoryEntry('123', 'src', kind='directory', parent_id=None))
63
68
    ('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
64
 
    >>> i.add(InventoryEntry('2323', 'bye.c', 'file', '123'))
 
69
    >>> i.add(InventoryEntry('2323', 'bye.c', parent_id='123'))
65
70
    Traceback (most recent call last):
66
71
    ...
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'))
 
72
    BzrError: ('inventory already contains entry with id {2323}', [])
 
73
    >>> i.add(InventoryEntry('2324', 'bye.c', parent_id='123'))
 
74
    >>> i.add(InventoryEntry('2325', 'wibble', parent_id='123', kind='directory'))
70
75
    >>> i.path2id('src/wibble')
71
76
    '2325'
72
77
    >>> '2325' in i
73
78
    True
74
 
    >>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
 
79
    >>> i.add(InventoryEntry('2326', 'wibble.c', parent_id='2325'))
75
80
    >>> i['2326']
76
81
    InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
77
82
    >>> for j in i.iter_entries():
86
91
    >>> i.id2path('2326')
87
92
    'src/wibble/wibble.c'
88
93
 
89
 
    TODO: Maybe also keep the full path of the entry, and the children?
 
94
    :todo: Maybe also keep the full path of the entry, and the children?
90
95
           But those depend on its position within a particular inventory, and
91
96
           it would be nice not to need to hold the backpointer here.
92
97
    """
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):
 
98
    def __init__(self, file_id, name, kind='file', text_id=None,
 
99
                 parent_id=None):
101
100
        """Create an InventoryEntry
102
101
        
103
102
        The filename must be a single component, relative to the
104
103
        parent directory; it cannot be a whole path or relative name.
105
104
 
106
 
        >>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
 
105
        >>> e = InventoryEntry('123', 'hello.c')
107
106
        >>> e.name
108
107
        'hello.c'
109
108
        >>> e.file_id
110
109
        '123'
111
 
        >>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
 
110
        >>> e = InventoryEntry('123', 'src/hello.c')
112
111
        Traceback (most recent call last):
113
 
        BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
 
112
        BzrError: ("InventoryEntry name is not a simple filename: 'src/hello.c'", [])
114
113
        """
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
 
    
 
114
        
 
115
        if len(splitpath(name)) != 1:
 
116
            bailout('InventoryEntry name is not a simple filename: %r'
 
117
                    % name)
 
118
        
121
119
        self.file_id = file_id
122
120
        self.name = name
 
121
        assert kind in ['file', 'directory']
123
122
        self.kind = kind
124
123
        self.text_id = text_id
125
124
        self.parent_id = parent_id
 
125
        self.text_sha1 = None
 
126
        self.text_size = None
126
127
        if kind == 'directory':
127
128
            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
139
129
 
140
130
 
141
131
    def copy(self):
142
132
        other = InventoryEntry(self.file_id, self.name, self.kind,
143
 
                               self.parent_id, text_id=self.text_id)
 
133
                               self.text_id, self.parent_id)
144
134
        other.text_sha1 = self.text_sha1
145
135
        other.text_size = self.text_size
146
 
        # note that children are *not* copied; they're pulled across when
147
 
        # others are added
148
136
        return other
149
137
 
150
138
 
159
147
    
160
148
    def to_element(self):
161
149
        """Convert to XML element"""
162
 
        from bzrlib.xml import Element
163
 
        
164
150
        e = Element('entry')
165
151
 
166
152
        e.set('name', self.name)
167
153
        e.set('file_id', self.file_id)
168
154
        e.set('kind', self.kind)
169
155
 
170
 
        if self.text_size != None:
 
156
        if self.text_size is not None:
171
157
            e.set('text_size', '%d' % self.text_size)
172
158
            
173
 
        for f in ['text_id', 'text_sha1']:
 
159
        for f in ['text_id', 'text_sha1', 'parent_id']:
174
160
            v = getattr(self, f)
175
 
            if v != None:
 
161
            if v is not None:
176
162
                e.set(f, v)
177
163
 
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
164
        e.tail = '\n'
186
165
            
187
166
        return e
189
168
 
190
169
    def from_element(cls, elt):
191
170
        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)
 
171
        self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'))
201
172
        self.text_id = elt.get('text_id')
202
173
        self.text_sha1 = elt.get('text_sha1')
 
174
        self.parent_id = elt.get('parent_id')
203
175
        
204
176
        ## mutter("read inventoryentry: %r" % (elt.attrib))
205
177
 
211
183
 
212
184
    from_element = classmethod(from_element)
213
185
 
214
 
    def __eq__(self, other):
 
186
    def __cmp__(self, other):
 
187
        if self is other:
 
188
            return 0
215
189
        if not isinstance(other, InventoryEntry):
216
190
            return NotImplemented
217
191
 
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):
 
192
        return cmp(self.file_id, other.file_id) \
 
193
               or cmp(self.name, other.name) \
 
194
               or cmp(self.text_sha1, other.text_sha1) \
 
195
               or cmp(self.text_size, other.text_size) \
 
196
               or cmp(self.text_id, other.text_id) \
 
197
               or cmp(self.parent_id, other.parent_id) \
 
198
               or cmp(self.kind, other.kind)
 
199
 
 
200
 
 
201
 
 
202
class Inventory(XMLMixin):
253
203
    """Inventory of versioned files in a tree.
254
204
 
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.
 
205
    An Inventory acts like a set of InventoryEntry items.  You can
 
206
    also look files up by their file_id or name.
 
207
    
 
208
    May be read from and written to a metadata file in a tree.  To
 
209
    manipulate the inventory (for example to add a file), it is read
 
210
    in, modified, and then written back out.
258
211
 
259
212
    The inventory represents a typical unix file tree, with
260
213
    directories containing files and subdirectories.  We never store
264
217
    returned quickly.
265
218
 
266
219
    InventoryEntry objects must not be modified after they are
267
 
    inserted, other than through the Inventory API.
 
220
    inserted.
268
221
 
269
222
    >>> inv = Inventory()
270
 
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
 
223
    >>> inv.write_xml(sys.stdout)
 
224
    <inventory>
 
225
    </inventory>
 
226
    >>> inv.add(InventoryEntry('123-123', 'hello.c'))
271
227
    >>> inv['123-123'].name
272
228
    'hello.c'
273
229
 
282
238
 
283
239
    >>> [x[0] for x in inv.iter_entries()]
284
240
    ['hello.c']
285
 
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
286
 
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
 
241
    
 
242
    >>> inv.write_xml(sys.stdout)
 
243
    <inventory>
 
244
    <entry file_id="123-123" kind="file" name="hello.c" />
 
245
    </inventory>
 
246
 
287
247
    """
288
 
    def __init__(self, root_id=ROOT_ID):
 
248
 
 
249
    ## TODO: Make sure only canonical filenames are stored.
 
250
 
 
251
    ## TODO: Do something sensible about the possible collisions on
 
252
    ## case-losing filesystems.  Perhaps we should just always forbid
 
253
    ## such collisions.
 
254
 
 
255
    ## TODO: No special cases for root, rather just give it a file id
 
256
    ## like everything else.
 
257
 
 
258
    ## TODO: Probably change XML serialization to use nesting
 
259
 
 
260
    def __init__(self):
289
261
        """Create or read an inventory.
290
262
 
291
263
        If a working directory is specified, the inventory is read
292
264
        from there.  If the file is specified, read from that. If not,
293
265
        the inventory is created empty.
294
 
 
295
 
        The inventory is created with a default root directory, with
296
 
        an id of None.
297
266
        """
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}
 
267
        self._root = InventoryEntry(None, '', kind='directory')
 
268
        self._byid = {None: self._root}
304
269
 
305
270
 
306
271
    def __iter__(self):
312
277
        return len(self._byid)
313
278
 
314
279
 
315
 
    def iter_entries(self, from_dir=None):
 
280
    def iter_entries(self, parent_id=None):
316
281
        """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()
 
282
        kids = self[parent_id].children.items()
324
283
        kids.sort()
325
284
        for name, ie in kids:
326
285
            yield name, ie
327
286
            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
 
287
                for cn, cie in self.iter_entries(parent_id=ie.file_id):
 
288
                    yield joinpath([name, cn]), cie
349
289
 
350
290
 
351
291
    def directories(self):
352
 
        """Return (path, entry) pairs for all directories, including the root.
 
292
        """Return (path, entry) pairs for all directories.
353
293
        """
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
        yield '', self._root
 
295
        for path, entry in self.iter_entries():
 
296
            if entry.kind == 'directory':
 
297
                yield path, entry
366
298
        
367
299
 
368
300
 
370
302
        """True if this entry contains a file with given id.
371
303
 
372
304
        >>> inv = Inventory()
373
 
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
 
305
        >>> inv.add(InventoryEntry('123', 'foo.c'))
374
306
        >>> '123' in inv
375
307
        True
376
308
        >>> '456' in inv
383
315
        """Return the entry for given file_id.
384
316
 
385
317
        >>> inv = Inventory()
386
 
        >>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
 
318
        >>> inv.add(InventoryEntry('123123', 'hello.c'))
387
319
        >>> inv['123123'].name
388
320
        'hello.c'
389
321
        """
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
 
322
        return self._byid[file_id]
 
323
 
401
324
 
402
325
    def get_child(self, parent_id, filename):
403
 
        return self[parent_id].children.get(filename)
 
326
        if parent_id == None:
 
327
            return self._root.children.get(filename)
 
328
        else:
 
329
            return self[parent_id].children.get(filename)
404
330
 
405
331
 
406
332
    def add(self, entry):
409
335
        To add  a file to a branch ready to be committed, use Branch.add,
410
336
        which calls this."""
411
337
        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)
 
338
            bailout("inventory already contains entry with id {%s}" % entry.file_id)
 
339
 
 
340
        parent = self._byid[entry.parent_id]
 
341
        if parent.kind != 'directory':
 
342
            bailout("attempt to add under non-directory {%s}" % parent.file_id)
421
343
 
422
344
        if parent.children.has_key(entry.name):
423
 
            raise BzrError("%s is already versioned" %
 
345
            bailout("%s is already versioned" %
424
346
                    appendpath(self.id2path(parent.file_id), entry.name))
425
347
 
426
348
        self._byid[entry.file_id] = entry
431
353
        """Add entry from a path.
432
354
 
433
355
        The immediate parent must already be versioned"""
434
 
        from bzrlib.branch import gen_file_id
435
 
        
436
356
        parts = bzrlib.osutils.splitpath(relpath)
437
357
        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
 
 
 
358
            bailout("cannot re-add root of inventory")
 
359
 
 
360
        if file_id is None:
 
361
            file_id = bzrlib.branch.gen_file_id(relpath)
 
362
 
 
363
        parent_id = self.path2id(parts[:-1])
448
364
        ie = InventoryEntry(file_id, parts[-1],
449
365
                            kind=kind, parent_id=parent_id)
450
366
        return self.add(ie)
454
370
        """Remove entry by id.
455
371
 
456
372
        >>> inv = Inventory()
457
 
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
 
373
        >>> inv.add(InventoryEntry('123', 'foo.c'))
458
374
        >>> '123' in inv
459
375
        True
460
376
        >>> del inv['123']
476
392
        del self[ie.parent_id].children[ie.name]
477
393
 
478
394
 
 
395
    def id_set(self):
 
396
        return Set(self._byid)
 
397
 
 
398
 
479
399
    def to_element(self):
480
400
        """Convert to XML Element"""
481
 
        from bzrlib.xml import Element
482
 
        
483
401
        e = Element('inventory')
484
402
        e.text = '\n'
485
 
        if self.root.file_id not in (None, ROOT_ID):
486
 
            e.set('file_id', self.root.file_id)
487
403
        for path, ie in self.iter_entries():
488
404
            e.append(ie.to_element())
489
405
        return e
491
407
 
492
408
    def from_element(cls, elt):
493
409
        """Construct from XML Element
494
 
        
 
410
 
495
411
        >>> inv = Inventory()
496
 
        >>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c', 'file', ROOT_ID))
 
412
        >>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c'))
497
413
        >>> elt = inv.to_element()
498
414
        >>> inv2 = Inventory.from_element(elt)
499
415
        >>> inv2 == inv
500
416
        True
501
417
        """
502
 
        # XXXX: doctest doesn't run this properly under python2.3
503
418
        assert elt.tag == 'inventory'
504
 
        root_id = elt.get('file_id') or ROOT_ID
505
 
        o = cls(root_id)
 
419
        o = cls()
506
420
        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)
 
421
            o.add(InventoryEntry.from_element(e))
511
422
        return o
512
423
        
513
424
    from_element = classmethod(from_element)
514
425
 
515
426
 
516
 
    def __eq__(self, other):
 
427
    def __cmp__(self, other):
517
428
        """Compare two sets by comparing their contents.
518
429
 
519
430
        >>> i1 = Inventory()
520
431
        >>> i2 = Inventory()
521
432
        >>> i1 == i2
522
433
        True
523
 
        >>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
 
434
        >>> i1.add(InventoryEntry('123', 'foo'))
524
435
        >>> i1 == i2
525
436
        False
526
 
        >>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
 
437
        >>> i2.add(InventoryEntry('123', 'foo'))
527
438
        >>> i1 == i2
528
439
        True
529
440
        """
 
441
        if self is other:
 
442
            return 0
 
443
        
530
444
        if not isinstance(other, Inventory):
531
445
            return NotImplemented
532
446
 
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
 
        """
 
447
        if self.id_set() ^ other.id_set():
 
448
            return 1
 
449
 
 
450
        for file_id in self._byid:
 
451
            c = cmp(self[file_id], other[file_id])
 
452
            if c: return c
 
453
 
 
454
        return 0
 
455
 
 
456
 
 
457
    def id2path(self, file_id):
 
458
        """Return as a list the path to file_id."""
557
459
        p = []
558
460
        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)
 
461
            ie = self._byid[file_id]
 
462
            p.insert(0, ie.name)
564
463
            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)
 
464
        return '/'.join(p)
574
465
            
575
466
 
576
467
 
582
473
 
583
474
        This returns the entry of the last component in the path,
584
475
        which may be either a file or a directory.
585
 
 
586
 
        Returns None iff the path is not found.
587
476
        """
588
477
        if isinstance(name, types.StringTypes):
589
478
            name = splitpath(name)
590
479
 
591
 
        mutter("lookup path %r" % name)
592
 
 
593
 
        parent = self.root
 
480
        parent = self[None]
594
481
        for f in name:
595
482
            try:
596
483
                cie = parent.children[f]
597
484
                assert cie.name == f
598
 
                assert cie.parent_id == parent.file_id
599
485
                parent = cie
600
486
            except KeyError:
601
487
                # or raise an error?
612
498
        return self._byid.has_key(file_id)
613
499
 
614
500
 
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))
 
501
 
 
502
 
 
503
 
 
504
if __name__ == '__main__':
 
505
    import doctest, inventory
 
506
    doctest.testmod(inventory)