← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« 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
 
# TODO: Maybe also keep the full path of the entry, and the children?
19
 
# But those depend on its position within a particular inventory, and
20
 
# it would be nice not to need to hold the backpointer here.
21
 
 
22
 
# TODO: Perhaps split InventoryEntry into subclasses for files,
23
 
# directories, etc etc.
24
 
 
25
 
 
26
 
# This should really be an id randomly assigned when the tree is
27
 
# created, but it's not for now.
28
 
ROOT_ID = "TREE_ROOT"
29
 
 
30
 
 
31
 
import os.path
32
 
import re
33
 
import sys
34
 
import types
 
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, 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
35
34
 
36
35
import bzrlib
37
 
from bzrlib.errors import BzrError, BzrCheckError
38
 
 
39
 
from bzrlib.osutils import quotefn, splitpath, joinpath, appendpath
 
36
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
40
37
from bzrlib.trace import mutter
41
 
from bzrlib.errors import NotVersionedError
42
 
 
43
 
 
44
 
class InventoryEntry(object):
 
38
 
 
39
class InventoryEntry(XMLMixin):
45
40
    """Description of a versioned file.
46
41
 
47
42
    An InventoryEntry has the following fields, which are also
48
43
    present in the XML inventory-entry element:
49
44
 
50
 
    file_id
51
 
 
52
 
    name
53
 
        (within the parent directory)
54
 
 
55
 
    kind
56
 
        'directory' or 'file'
57
 
 
58
 
    parent_id
59
 
        file_id of the parent directory, or ROOT_ID
60
 
 
61
 
    name_version
62
 
        the revision_id in which the name or parent of this file was
63
 
        last changed
64
 
 
65
 
    text_sha1
66
 
        sha-1 of the text of the file
67
 
        
68
 
    text_size
69
 
        size in bytes of the text of the file
70
 
        
71
 
    text_version
72
 
        the revision_id in which the text of this file was introduced
73
 
 
74
 
    (reading a version 4 tree created a text_id field.)
 
45
    * *file_id*
 
46
    * *name*: (only the basename within the directory, must not
 
47
      contain slashes)
 
48
    * *kind*: "directory" or "file"
 
49
    * *directory_id*: (if absent/null means the branch root directory)
 
50
    * *text_sha1*: only for files
 
51
    * *text_size*: in bytes, only for files 
 
52
    * *text_id*: identifier for the text version, only for files
 
53
 
 
54
    InventoryEntries can also exist inside a WorkingTree
 
55
    inventory, in which case they are not yet bound to a
 
56
    particular revision of the file.  In that case the text_sha1,
 
57
    text_size and text_id are absent.
 
58
 
75
59
 
76
60
    >>> i = Inventory()
77
61
    >>> i.path2id('')
78
 
    'TREE_ROOT'
79
 
    >>> i.add(InventoryEntry('123', 'src', 'directory', ROOT_ID))
80
 
    InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT')
81
 
    >>> i.add(InventoryEntry('2323', 'hello.c', 'file', parent_id='123'))
82
 
    InventoryEntry('2323', 'hello.c', kind='file', parent_id='123')
 
62
    >>> i.add(InventoryEntry('123', 'src', kind='directory'))
 
63
    >>> i.add(InventoryEntry('2323', 'hello.c', parent_id='123'))
83
64
    >>> for j in i.iter_entries():
84
65
    ...   print j
85
66
    ... 
86
 
    ('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
 
67
    ('src', InventoryEntry('123', 'src', kind='directory', parent_id=None))
87
68
    ('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
88
 
    >>> i.add(InventoryEntry('2323', 'bye.c', 'file', '123'))
 
69
    >>> i.add(InventoryEntry('2323', 'bye.c', parent_id='123'))
89
70
    Traceback (most recent call last):
90
71
    ...
91
 
    BzrError: inventory already contains entry with id {2323}
92
 
    >>> i.add(InventoryEntry('2324', 'bye.c', 'file', '123'))
93
 
    InventoryEntry('2324', 'bye.c', kind='file', parent_id='123')
94
 
    >>> i.add(InventoryEntry('2325', 'wibble', 'directory', '123'))
95
 
    InventoryEntry('2325', 'wibble', kind='directory', parent_id='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'))
96
75
    >>> i.path2id('src/wibble')
97
76
    '2325'
98
77
    >>> '2325' in i
99
78
    True
100
 
    >>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
101
 
    InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
 
79
    >>> i.add(InventoryEntry('2326', 'wibble.c', parent_id='2325'))
102
80
    >>> i['2326']
103
81
    InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
104
 
    >>> for path, entry in i.iter_entries():
105
 
    ...     print path.replace('\\\\', '/')     # for win32 os.sep
106
 
    ...     assert i.path2id(path)
 
82
    >>> for j in i.iter_entries():
 
83
    ...     print j[0]
 
84
    ...     assert i.path2id(j[0])
107
85
    ... 
108
86
    src
109
87
    src/bye.c
110
88
    src/hello.c
111
89
    src/wibble
112
90
    src/wibble/wibble.c
113
 
    >>> i.id2path('2326').replace('\\\\', '/')
 
91
    >>> i.id2path('2326')
114
92
    'src/wibble/wibble.c'
 
93
 
 
94
    :todo: Maybe also keep the full path of the entry, and the children?
 
95
           But those depend on its position within a particular inventory, and
 
96
           it would be nice not to need to hold the backpointer here.
115
97
    """
116
 
    
117
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
118
 
                 'text_id', 'parent_id', 'children',
119
 
                 'text_version', 'name_version', ]
120
 
 
121
 
 
122
 
    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):
123
100
        """Create an InventoryEntry
124
101
        
125
102
        The filename must be a single component, relative to the
126
103
        parent directory; it cannot be a whole path or relative name.
127
104
 
128
 
        >>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
 
105
        >>> e = InventoryEntry('123', 'hello.c')
129
106
        >>> e.name
130
107
        'hello.c'
131
108
        >>> e.file_id
132
109
        '123'
133
 
        >>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
 
110
        >>> e = InventoryEntry('123', 'src/hello.c')
134
111
        Traceback (most recent call last):
135
 
        BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
 
112
        BzrError: ("InventoryEntry name is not a simple filename: 'src/hello.c'", [])
136
113
        """
137
 
        assert isinstance(name, basestring), name
138
 
        if '/' in name or '\\' in name:
139
 
            raise BzrCheckError('InventoryEntry name %r is invalid' % name)
140
 
        
141
 
        self.text_version = None
142
 
        self.name_version = None
143
 
        self.text_sha1 = None
144
 
        self.text_size = None
 
114
        
 
115
        if len(splitpath(name)) != 1:
 
116
            bailout('InventoryEntry name is not a simple filename: %r'
 
117
                    % name)
 
118
        
145
119
        self.file_id = file_id
146
120
        self.name = name
 
121
        assert kind in ['file', 'directory']
147
122
        self.kind = kind
148
123
        self.text_id = text_id
149
124
        self.parent_id = parent_id
 
125
        self.text_sha1 = None
 
126
        self.text_size = None
150
127
        if kind == 'directory':
151
128
            self.children = {}
152
 
        elif kind == 'file':
153
 
            pass
154
 
        else:
155
 
            raise BzrError("unhandled entry kind %r" % kind)
156
 
 
157
129
 
158
130
 
159
131
    def sorted_children(self):
164
136
 
165
137
    def copy(self):
166
138
        other = InventoryEntry(self.file_id, self.name, self.kind,
167
 
                               self.parent_id)
168
 
        other.text_id = self.text_id
 
139
                               self.text_id, self.parent_id)
169
140
        other.text_sha1 = self.text_sha1
170
141
        other.text_size = self.text_size
171
 
        other.text_version = self.text_version
172
 
        other.name_version = self.name_version
173
 
        # note that children are *not* copied; they're pulled across when
174
 
        # others are added
175
142
        return other
176
143
 
177
144
 
184
151
                   self.parent_id))
185
152
 
186
153
    
187
 
    def __eq__(self, other):
 
154
    def to_element(self):
 
155
        """Convert to XML element"""
 
156
        e = Element('entry')
 
157
 
 
158
        e.set('name', self.name)
 
159
        e.set('file_id', self.file_id)
 
160
        e.set('kind', self.kind)
 
161
 
 
162
        if self.text_size is not None:
 
163
            e.set('text_size', '%d' % self.text_size)
 
164
            
 
165
        for f in ['text_id', 'text_sha1', 'parent_id']:
 
166
            v = getattr(self, f)
 
167
            if v is not None:
 
168
                e.set(f, v)
 
169
 
 
170
        e.tail = '\n'
 
171
            
 
172
        return e
 
173
 
 
174
 
 
175
    def from_element(cls, elt):
 
176
        assert elt.tag == 'entry'
 
177
        self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'))
 
178
        self.text_id = elt.get('text_id')
 
179
        self.text_sha1 = elt.get('text_sha1')
 
180
        self.parent_id = elt.get('parent_id')
 
181
        
 
182
        ## mutter("read inventoryentry: %r" % (elt.attrib))
 
183
 
 
184
        v = elt.get('text_size')
 
185
        self.text_size = v and int(v)
 
186
 
 
187
        return self
 
188
            
 
189
 
 
190
    from_element = classmethod(from_element)
 
191
 
 
192
    def __cmp__(self, other):
 
193
        if self is other:
 
194
            return 0
188
195
        if not isinstance(other, InventoryEntry):
189
196
            return NotImplemented
190
197
 
191
 
        return (self.file_id == other.file_id) \
192
 
               and (self.name == other.name) \
193
 
               and (self.text_sha1 == other.text_sha1) \
194
 
               and (self.text_size == other.text_size) \
195
 
               and (self.text_id == other.text_id) \
196
 
               and (self.parent_id == other.parent_id) \
197
 
               and (self.kind == other.kind) \
198
 
               and (self.text_version == other.text_version) \
199
 
               and (self.name_version == other.name_version)
200
 
 
201
 
 
202
 
    def __ne__(self, other):
203
 
        return not (self == other)
204
 
 
205
 
    def __hash__(self):
206
 
        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)
207
205
 
208
206
 
209
207
 
215
213
        self.parent_id = None
216
214
        self.name = ''
217
215
 
218
 
    def __eq__(self, other):
 
216
    def __cmp__(self, other):
 
217
        if self is other:
 
218
            return 0
219
219
        if not isinstance(other, RootEntry):
220
220
            return NotImplemented
221
 
        
222
 
        return (self.file_id == other.file_id) \
223
 
               and (self.children == other.children)
224
 
 
225
 
 
226
 
 
227
 
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):
228
227
    """Inventory of versioned files in a tree.
229
228
 
230
 
    This describes which file_id is present at each point in the tree,
231
 
    and possibly the SHA-1 or other information about the file.
232
 
    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.
233
235
 
234
236
    The inventory represents a typical unix file tree, with
235
237
    directories containing files and subdirectories.  We never store
242
244
    inserted, other than through the Inventory API.
243
245
 
244
246
    >>> inv = Inventory()
245
 
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
246
 
    InventoryEntry('123-123', 'hello.c', kind='file', parent_id='TREE_ROOT')
 
247
    >>> inv.write_xml(sys.stdout)
 
248
    <inventory>
 
249
    </inventory>
 
250
    >>> inv.add(InventoryEntry('123-123', 'hello.c'))
247
251
    >>> inv['123-123'].name
248
252
    'hello.c'
249
253
 
258
262
 
259
263
    >>> [x[0] for x in inv.iter_entries()]
260
264
    ['hello.c']
261
 
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
262
 
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
263
 
    InventoryEntry('123-123', 'hello.c', kind='file', parent_id='TREE_ROOT-12345678-12345678')
 
265
    
 
266
    >>> inv.write_xml(sys.stdout)
 
267
    <inventory>
 
268
    <entry file_id="123-123" kind="file" name="hello.c" />
 
269
    </inventory>
 
270
 
264
271
    """
265
 
    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):
266
285
        """Create or read an inventory.
267
286
 
268
287
        If a working directory is specified, the inventory is read
272
291
        The inventory is created with a default root directory, with
273
292
        an id of None.
274
293
        """
275
 
        # We are letting Branch.initialize() create a unique inventory
276
 
        # root id. Rather than generating a random one here.
277
 
        #if root_id is None:
278
 
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
279
 
        self.root = RootEntry(root_id)
280
 
        self._byid = {self.root.file_id: self.root}
281
 
 
282
 
 
283
 
    def copy(self):
284
 
        other = Inventory(self.root.file_id)
285
 
        # copy recursively so we know directories will be added before
286
 
        # their children.  There are more efficient ways than this...
287
 
        for path, entry in self.iter_entries():
288
 
            if entry == self.root:
289
 
                continue
290
 
            other.add(entry.copy())
291
 
        return other
 
294
        self.root = RootEntry(None)
 
295
        self._byid = {None: self.root}
292
296
 
293
297
 
294
298
    def __iter__(self):
314
318
            yield name, ie
315
319
            if ie.kind == 'directory':
316
320
                for cn, cie in self.iter_entries(from_dir=ie.file_id):
317
 
                    yield os.path.join(name, cn), cie
318
 
 
319
 
 
320
 
    def entries(self):
321
 
        """Return list of (path, ie) for all entries except the root.
322
 
 
323
 
        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.
324
327
        """
325
 
        accum = []
326
 
        def descend(dir_ie, dir_path):
327
 
            kids = dir_ie.children.items()
328
 
            kids.sort()
329
 
            for name, ie in kids:
330
 
                child_path = os.path.join(dir_path, name)
331
 
                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():
332
335
                if ie.kind == 'directory':
333
 
                    descend(ie, child_path)
334
 
 
335
 
        descend(self.root, '')
336
 
        return accum
337
 
 
338
 
 
339
 
    def directories(self):
340
 
        """Return (path, entry) pairs for all directories, including the root.
341
 
        """
342
 
        accum = []
343
 
        def descend(parent_ie, parent_path):
344
 
            accum.append((parent_path, parent_ie))
 
336
                    dn.append((ie.name, ie))
 
337
            dn.sort()
345
338
            
346
 
            kids = [(ie.name, ie) for ie in parent_ie.children.itervalues() if ie.kind == 'directory']
347
 
            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
348
342
 
349
 
            for name, child_ie in kids:
350
 
                child_path = os.path.join(parent_path, name)
351
 
                descend(child_ie, child_path)
352
 
        descend(self.root, '')
353
 
        return accum
 
343
        for name, ie in descend(self.root):
 
344
            yield name, ie
354
345
        
355
346
 
356
347
 
358
349
        """True if this entry contains a file with given id.
359
350
 
360
351
        >>> inv = Inventory()
361
 
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
362
 
        InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
 
352
        >>> inv.add(InventoryEntry('123', 'foo.c'))
363
353
        >>> '123' in inv
364
354
        True
365
355
        >>> '456' in inv
372
362
        """Return the entry for given file_id.
373
363
 
374
364
        >>> inv = Inventory()
375
 
        >>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
376
 
        InventoryEntry('123123', 'hello.c', kind='file', parent_id='TREE_ROOT')
 
365
        >>> inv.add(InventoryEntry('123123', 'hello.c'))
377
366
        >>> inv['123123'].name
378
367
        'hello.c'
379
368
        """
380
 
        try:
381
 
            return self._byid[file_id]
382
 
        except KeyError:
383
 
            if file_id == None:
384
 
                raise BzrError("can't look up file_id None")
385
 
            else:
386
 
                raise BzrError("file_id {%s} not in inventory" % file_id)
387
 
 
388
 
 
389
 
    def get_file_kind(self, file_id):
390
 
        return self._byid[file_id].kind
 
369
        return self._byid[file_id]
 
370
 
391
371
 
392
372
    def get_child(self, parent_id, filename):
393
373
        return self[parent_id].children.get(filename)
397
377
        """Add entry to inventory.
398
378
 
399
379
        To add  a file to a branch ready to be committed, use Branch.add,
400
 
        which calls this.
401
 
 
402
 
        Returns the new entry object.
403
 
        """
 
380
        which calls this."""
404
381
        if entry.file_id in self._byid:
405
 
            raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
406
 
 
407
 
        if entry.parent_id == ROOT_ID or entry.parent_id is None:
408
 
            entry.parent_id = self.root.file_id
 
382
            bailout("inventory already contains entry with id {%s}" % entry.file_id)
409
383
 
410
384
        try:
411
385
            parent = self._byid[entry.parent_id]
412
386
        except KeyError:
413
 
            raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
 
387
            bailout("parent_id %r not in inventory" % entry.parent_id)
414
388
 
415
389
        if parent.children.has_key(entry.name):
416
 
            raise BzrError("%s is already versioned" %
 
390
            bailout("%s is already versioned" %
417
391
                    appendpath(self.id2path(parent.file_id), entry.name))
418
392
 
419
393
        self._byid[entry.file_id] = entry
420
394
        parent.children[entry.name] = entry
421
 
        return entry
422
395
 
423
396
 
424
397
    def add_path(self, relpath, kind, file_id=None):
425
398
        """Add entry from a path.
426
399
 
427
 
        The immediate parent must already be versioned.
428
 
 
429
 
        Returns the new entry object."""
430
 
        from bzrlib.branch import gen_file_id
431
 
        
 
400
        The immediate parent must already be versioned"""
432
401
        parts = bzrlib.osutils.splitpath(relpath)
433
402
        if len(parts) == 0:
434
 
            raise BzrError("cannot re-add root of inventory")
435
 
 
436
 
        if file_id == None:
437
 
            file_id = gen_file_id(relpath)
438
 
 
439
 
        parent_path = parts[:-1]
440
 
        parent_id = self.path2id(parent_path)
441
 
        if parent_id == None:
442
 
            raise NotVersionedError(parent_path)
443
 
 
 
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])
444
409
        ie = InventoryEntry(file_id, parts[-1],
445
410
                            kind=kind, parent_id=parent_id)
446
411
        return self.add(ie)
450
415
        """Remove entry by id.
451
416
 
452
417
        >>> inv = Inventory()
453
 
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
454
 
        InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
 
418
        >>> inv.add(InventoryEntry('123', 'foo.c'))
455
419
        >>> '123' in inv
456
420
        True
457
421
        >>> del inv['123']
473
437
        del self[ie.parent_id].children[ie.name]
474
438
 
475
439
 
476
 
    def __eq__(self, other):
 
440
    def id_set(self):
 
441
        return Set(self._byid)
 
442
 
 
443
 
 
444
    def to_element(self):
 
445
        """Convert to XML Element"""
 
446
        e = Element('inventory')
 
447
        e.text = '\n'
 
448
        for path, ie in self.iter_entries():
 
449
            e.append(ie.to_element())
 
450
        return e
 
451
    
 
452
 
 
453
    def from_element(cls, elt):
 
454
        """Construct from XML Element
 
455
 
 
456
        >>> inv = Inventory()
 
457
        >>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c'))
 
458
        >>> elt = inv.to_element()
 
459
        >>> inv2 = Inventory.from_element(elt)
 
460
        >>> inv2 == inv
 
461
        True
 
462
        """
 
463
        assert elt.tag == 'inventory'
 
464
        o = cls()
 
465
        for e in elt:
 
466
            o.add(InventoryEntry.from_element(e))
 
467
        return o
 
468
        
 
469
    from_element = classmethod(from_element)
 
470
 
 
471
 
 
472
    def __cmp__(self, other):
477
473
        """Compare two sets by comparing their contents.
478
474
 
479
475
        >>> i1 = Inventory()
480
476
        >>> i2 = Inventory()
481
477
        >>> i1 == i2
482
478
        True
483
 
        >>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
484
 
        InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
 
479
        >>> i1.add(InventoryEntry('123', 'foo'))
485
480
        >>> i1 == i2
486
481
        False
487
 
        >>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
488
 
        InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
 
482
        >>> i2.add(InventoryEntry('123', 'foo'))
489
483
        >>> i1 == i2
490
484
        True
491
485
        """
 
486
        if self is other:
 
487
            return 0
 
488
        
492
489
        if not isinstance(other, Inventory):
493
490
            return NotImplemented
494
491
 
495
 
        if len(self._byid) != len(other._byid):
496
 
            # shortcut: obviously not the same
497
 
            return False
498
 
 
499
 
        return self._byid == other._byid
500
 
 
501
 
 
502
 
    def __ne__(self, other):
503
 
        return not self.__eq__(other)
504
 
 
505
 
 
506
 
    def __hash__(self):
507
 
        raise ValueError('not hashable')
508
 
 
509
 
 
510
 
    def get_idpath(self, file_id):
511
 
        """Return a list of file_ids for the path to an entry.
512
 
 
513
 
        The list contains one element for each directory followed by
514
 
        the id of the file itself.  So the length of the returned list
515
 
        is equal to the depth of the file in the tree, counting the
516
 
        root directory as depth 1.
517
 
        """
 
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."""
518
504
        p = []
519
505
        while file_id != None:
520
 
            try:
521
 
                ie = self._byid[file_id]
522
 
            except KeyError:
523
 
                raise BzrError("file_id {%s} not found in inventory" % file_id)
524
 
            p.insert(0, ie.file_id)
 
506
            ie = self._byid[file_id]
 
507
            p.insert(0, ie.name)
525
508
            file_id = ie.parent_id
526
 
        return p
527
 
 
528
 
 
529
 
    def id2path(self, file_id):
530
 
        """Return as a list the path to file_id."""
531
 
 
532
 
        # get all names, skipping root
533
 
        p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
534
 
        return os.sep.join(p)
 
509
        return '/'.join(p)
535
510
            
536
511
 
537
512
 
543
518
 
544
519
        This returns the entry of the last component in the path,
545
520
        which may be either a file or a directory.
546
 
 
547
 
        Returns None iff the path is not found.
548
521
        """
549
522
        if isinstance(name, types.StringTypes):
550
523
            name = splitpath(name)
551
524
 
552
 
        mutter("lookup path %r" % name)
553
 
 
554
 
        parent = self.root
 
525
        parent = self[None]
555
526
        for f in name:
556
527
            try:
557
528
                cie = parent.children[f]
558
529
                assert cie.name == f
559
 
                assert cie.parent_id == parent.file_id
560
530
                parent = cie
561
531
            except KeyError:
562
532
                # or raise an error?
580
550
 
581
551
        This does not move the working file."""
582
552
        if not is_valid_name(new_name):
583
 
            raise BzrError("not an acceptable filename: %r" % new_name)
 
553
            bailout("not an acceptable filename: %r" % new_name)
584
554
 
585
555
        new_parent = self._byid[new_parent_id]
586
556
        if new_name in new_parent.children:
587
 
            raise BzrError("%r already exists in %r" % (new_name, self.id2path(new_parent_id)))
588
 
 
589
 
        new_parent_idpath = self.get_idpath(new_parent_id)
590
 
        if file_id in new_parent_idpath:
591
 
            raise BzrError("cannot move directory %r into a subdirectory of itself, %r"
592
 
                    % (self.id2path(file_id), self.id2path(new_parent_id)))
 
557
            bailout("%r already exists in %r" % (new_name, self.id2path(new_parent_id)))
593
558
 
594
559
        file_ie = self._byid[file_id]
595
560
        old_parent = self._byid[file_ie.parent_id]
605
570
 
606
571
 
607
572
 
608
 
_NAME_RE = None
 
573
_NAME_RE = re.compile(r'^[^/\\]+$')
609
574
 
610
575
def is_valid_name(name):
611
 
    global _NAME_RE
612
 
    if _NAME_RE == None:
613
 
        _NAME_RE = re.compile(r'^[^/\\]+$')
614
 
        
615
576
    return bool(_NAME_RE.match(name))
 
577
 
 
578
 
 
579
 
 
580
if __name__ == '__main__':
 
581
    import doctest, inventory
 
582
    doctest.testmod(inventory)