/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: Martin Pool
  • Date: 2005-08-04 22:04:40 UTC
  • Revision ID: mbp@sourcefrog.net-20050804220440-99562df8151d1ac5
- add pending merge from aaron

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