/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-04-05 08:24:51 UTC
  • Revision ID: mbp@sourcefrog.net-20050405082451-408ebb0fd108440f
start adding quotes

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
 
 
 
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>"
22
23
 
23
24
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
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
129
 
134
130
 
135
131
    def sorted_children(self):
140
136
 
141
137
    def copy(self):
142
138
        other = InventoryEntry(self.file_id, self.name, self.kind,
143
 
                               self.parent_id, text_id=self.text_id)
 
139
                               self.text_id, self.parent_id)
144
140
        other.text_sha1 = self.text_sha1
145
141
        other.text_size = self.text_size
146
 
        # note that children are *not* copied; they're pulled across when
147
 
        # others are added
148
142
        return other
149
143
 
150
144
 
159
153
    
160
154
    def to_element(self):
161
155
        """Convert to XML element"""
162
 
        from bzrlib.xml import Element
163
 
        
164
156
        e = Element('entry')
165
157
 
166
158
        e.set('name', self.name)
167
159
        e.set('file_id', self.file_id)
168
160
        e.set('kind', self.kind)
169
161
 
170
 
        if self.text_size != None:
 
162
        if self.text_size is not None:
171
163
            e.set('text_size', '%d' % self.text_size)
172
164
            
173
 
        for f in ['text_id', 'text_sha1']:
 
165
        for f in ['text_id', 'text_sha1', 'parent_id']:
174
166
            v = getattr(self, f)
175
 
            if v != None:
 
167
            if v is not None:
176
168
                e.set(f, v)
177
169
 
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
170
        e.tail = '\n'
186
171
            
187
172
        return e
189
174
 
190
175
    def from_element(cls, elt):
191
176
        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)
 
177
        self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'))
201
178
        self.text_id = elt.get('text_id')
202
179
        self.text_sha1 = elt.get('text_sha1')
 
180
        self.parent_id = elt.get('parent_id')
203
181
        
204
182
        ## mutter("read inventoryentry: %r" % (elt.attrib))
205
183
 
211
189
 
212
190
    from_element = classmethod(from_element)
213
191
 
214
 
    def __eq__(self, other):
 
192
    def __cmp__(self, other):
 
193
        if self is other:
 
194
            return 0
215
195
        if not isinstance(other, InventoryEntry):
216
196
            return NotImplemented
217
197
 
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')
 
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)
232
205
 
233
206
 
234
207
 
240
213
        self.parent_id = None
241
214
        self.name = ''
242
215
 
243
 
    def __eq__(self, other):
 
216
    def __cmp__(self, other):
 
217
        if self is other:
 
218
            return 0
244
219
        if not isinstance(other, RootEntry):
245
220
            return NotImplemented
246
 
        
247
 
        return (self.file_id == other.file_id) \
248
 
               and (self.children == other.children)
249
 
 
250
 
 
251
 
 
252
 
class Inventory(object):
 
221
        return cmp(self.file_id, other.file_id) \
 
222
               or cmp(self.children, other.children)
 
223
 
 
224
 
 
225
 
 
226
class Inventory(XMLMixin):
253
227
    """Inventory of versioned files in a tree.
254
228
 
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.
 
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.
258
235
 
259
236
    The inventory represents a typical unix file tree, with
260
237
    directories containing files and subdirectories.  We never store
267
244
    inserted, other than through the Inventory API.
268
245
 
269
246
    >>> inv = Inventory()
270
 
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
 
247
    >>> inv.write_xml(sys.stdout)
 
248
    <inventory>
 
249
    </inventory>
 
250
    >>> inv.add(InventoryEntry('123-123', 'hello.c'))
271
251
    >>> inv['123-123'].name
272
252
    'hello.c'
273
253
 
282
262
 
283
263
    >>> [x[0] for x in inv.iter_entries()]
284
264
    ['hello.c']
285
 
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
286
 
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
 
265
    
 
266
    >>> inv.write_xml(sys.stdout)
 
267
    <inventory>
 
268
    <entry file_id="123-123" kind="file" name="hello.c" />
 
269
    </inventory>
 
270
 
287
271
    """
288
 
    def __init__(self, root_id=ROOT_ID):
 
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):
289
285
        """Create or read an inventory.
290
286
 
291
287
        If a working directory is specified, the inventory is read
295
291
        The inventory is created with a default root directory, with
296
292
        an id of None.
297
293
        """
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}
 
294
        self.root = RootEntry(None)
 
295
        self._byid = {None: self.root}
304
296
 
305
297
 
306
298
    def __iter__(self):
326
318
            yield name, ie
327
319
            if ie.kind == 'directory':
328
320
                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.
 
321
                    yield '/'.join((name, cn)), cie
 
322
                    
 
323
 
 
324
 
 
325
    def directories(self, from_dir=None):
 
326
        """Return (path, entry) pairs for all directories.
336
327
        """
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))
 
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():
344
335
                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))
 
336
                    dn.append((ie.name, ie))
 
337
            dn.sort()
357
338
            
358
 
            kids = [(ie.name, ie) for ie in parent_ie.children.itervalues() if ie.kind == 'directory']
359
 
            kids.sort()
 
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
360
342
 
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
 
343
        for name, ie in descend(self.root):
 
344
            yield name, ie
366
345
        
367
346
 
368
347
 
370
349
        """True if this entry contains a file with given id.
371
350
 
372
351
        >>> inv = Inventory()
373
 
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
 
352
        >>> inv.add(InventoryEntry('123', 'foo.c'))
374
353
        >>> '123' in inv
375
354
        True
376
355
        >>> '456' in inv
383
362
        """Return the entry for given file_id.
384
363
 
385
364
        >>> inv = Inventory()
386
 
        >>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
 
365
        >>> inv.add(InventoryEntry('123123', 'hello.c'))
387
366
        >>> inv['123123'].name
388
367
        'hello.c'
389
368
        """
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
 
369
        return self._byid[file_id]
 
370
 
401
371
 
402
372
    def get_child(self, parent_id, filename):
403
373
        return self[parent_id].children.get(filename)
409
379
        To add  a file to a branch ready to be committed, use Branch.add,
410
380
        which calls this."""
411
381
        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
 
382
            bailout("inventory already contains entry with id {%s}" % entry.file_id)
416
383
 
417
384
        try:
418
385
            parent = self._byid[entry.parent_id]
419
386
        except KeyError:
420
 
            raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
 
387
            bailout("parent_id %r not in inventory" % entry.parent_id)
421
388
 
422
389
        if parent.children.has_key(entry.name):
423
 
            raise BzrError("%s is already versioned" %
 
390
            bailout("%s is already versioned" %
424
391
                    appendpath(self.id2path(parent.file_id), entry.name))
425
392
 
426
393
        self._byid[entry.file_id] = entry
431
398
        """Add entry from a path.
432
399
 
433
400
        The immediate parent must already be versioned"""
434
 
        from bzrlib.branch import gen_file_id
435
 
        
436
401
        parts = bzrlib.osutils.splitpath(relpath)
437
402
        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
 
 
 
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])
448
409
        ie = InventoryEntry(file_id, parts[-1],
449
410
                            kind=kind, parent_id=parent_id)
450
411
        return self.add(ie)
454
415
        """Remove entry by id.
455
416
 
456
417
        >>> inv = Inventory()
457
 
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
 
418
        >>> inv.add(InventoryEntry('123', 'foo.c'))
458
419
        >>> '123' in inv
459
420
        True
460
421
        >>> del inv['123']
476
437
        del self[ie.parent_id].children[ie.name]
477
438
 
478
439
 
 
440
    def id_set(self):
 
441
        return Set(self._byid)
 
442
 
 
443
 
479
444
    def to_element(self):
480
445
        """Convert to XML Element"""
481
 
        from bzrlib.xml import Element
482
 
        
483
446
        e = Element('inventory')
484
447
        e.text = '\n'
485
 
        if self.root.file_id not in (None, ROOT_ID):
486
 
            e.set('file_id', self.root.file_id)
487
448
        for path, ie in self.iter_entries():
488
449
            e.append(ie.to_element())
489
450
        return e
491
452
 
492
453
    def from_element(cls, elt):
493
454
        """Construct from XML Element
494
 
        
 
455
 
495
456
        >>> inv = Inventory()
496
 
        >>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c', 'file', ROOT_ID))
 
457
        >>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c'))
497
458
        >>> elt = inv.to_element()
498
459
        >>> inv2 = Inventory.from_element(elt)
499
460
        >>> inv2 == inv
500
461
        True
501
462
        """
502
 
        # XXXX: doctest doesn't run this properly under python2.3
503
463
        assert elt.tag == 'inventory'
504
 
        root_id = elt.get('file_id') or ROOT_ID
505
 
        o = cls(root_id)
 
464
        o = cls()
506
465
        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)
 
466
            o.add(InventoryEntry.from_element(e))
511
467
        return o
512
468
        
513
469
    from_element = classmethod(from_element)
514
470
 
515
471
 
516
 
    def __eq__(self, other):
 
472
    def __cmp__(self, other):
517
473
        """Compare two sets by comparing their contents.
518
474
 
519
475
        >>> i1 = Inventory()
520
476
        >>> i2 = Inventory()
521
477
        >>> i1 == i2
522
478
        True
523
 
        >>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
 
479
        >>> i1.add(InventoryEntry('123', 'foo'))
524
480
        >>> i1 == i2
525
481
        False
526
 
        >>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
 
482
        >>> i2.add(InventoryEntry('123', 'foo'))
527
483
        >>> i1 == i2
528
484
        True
529
485
        """
 
486
        if self is other:
 
487
            return 0
 
488
        
530
489
        if not isinstance(other, Inventory):
531
490
            return NotImplemented
532
491
 
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
 
        """
 
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."""
557
504
        p = []
558
505
        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)
 
506
            ie = self._byid[file_id]
 
507
            p.insert(0, ie.name)
564
508
            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)
 
509
        return '/'.join(p)
574
510
            
575
511
 
576
512
 
582
518
 
583
519
        This returns the entry of the last component in the path,
584
520
        which may be either a file or a directory.
585
 
 
586
 
        Returns None iff the path is not found.
587
521
        """
588
522
        if isinstance(name, types.StringTypes):
589
523
            name = splitpath(name)
590
524
 
591
 
        mutter("lookup path %r" % name)
592
 
 
593
 
        parent = self.root
 
525
        parent = self[None]
594
526
        for f in name:
595
527
            try:
596
528
                cie = parent.children[f]
597
529
                assert cie.name == f
598
 
                assert cie.parent_id == parent.file_id
599
530
                parent = cie
600
531
            except KeyError:
601
532
                # or raise an error?
619
550
 
620
551
        This does not move the working file."""
621
552
        if not is_valid_name(new_name):
622
 
            raise BzrError("not an acceptable filename: %r" % new_name)
 
553
            bailout("not an acceptable filename: %r" % new_name)
623
554
 
624
555
        new_parent = self._byid[new_parent_id]
625
556
        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)))
 
557
            bailout("%r already exists in %r" % (new_name, self.id2path(new_parent_id)))
632
558
 
633
559
        file_ie = self._byid[file_id]
634
560
        old_parent = self._byid[file_ie.parent_id]
648
574
 
649
575
def is_valid_name(name):
650
576
    return bool(_NAME_RE.match(name))
 
577
 
 
578
 
 
579
 
 
580
if __name__ == '__main__':
 
581
    import doctest, inventory
 
582
    doctest.testmod(inventory)