← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

- stub for revision properties

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory.py
1
 
#! /usr/bin/env python
2
 
# -*- coding: UTF-8 -*-
3
 
 
 
1
# (C) 2005 Canonical Ltd
 
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
6
5
# the Free Software Foundation; either version 2 of the License, or
7
6
# (at your option) any later version.
8
 
 
 
7
#
9
8
# This program is distributed in the hope that it will be useful,
10
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
11
# GNU General Public License for more details.
13
 
 
 
12
#
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
16
 
18
 
"""Inventories map files to their name in a revision."""
19
 
 
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
34
 
from osutils import uuid, quotefn, splitpath, joinpath, appendpath
35
 
from trace import mutter
36
 
 
37
 
class InventoryEntry(XMLMixin):
 
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
# This should really be an id randomly assigned when the tree is
 
23
# created, but it's not for now.
 
24
ROOT_ID = "TREE_ROOT"
 
25
 
 
26
 
 
27
import os.path
 
28
import re
 
29
import sys
 
30
import tarfile
 
31
import types
 
32
 
 
33
import bzrlib
 
34
from bzrlib.errors import BzrError, BzrCheckError
 
35
 
 
36
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
 
37
                            appendpath, sha_strings)
 
38
from bzrlib.trace import mutter
 
39
from bzrlib.errors import NotVersionedError
 
40
 
 
41
 
 
42
class InventoryEntry(object):
38
43
    """Description of a versioned file.
39
44
 
40
45
    An InventoryEntry has the following fields, which are also
41
46
    present in the XML inventory-entry element:
42
47
 
43
 
    * *file_id*
44
 
    * *name*: (only the basename within the directory, must not
45
 
      contain slashes)
46
 
    * *kind*: "directory" or "file"
47
 
    * *directory_id*: (if absent/null means the branch root directory)
48
 
    * *text_sha1*: only for files
49
 
    * *text_size*: in bytes, only for files 
50
 
    * *text_id*: identifier for the text version, only for files
51
 
 
52
 
    InventoryEntries can also exist inside a WorkingTree
53
 
    inventory, in which case they are not yet bound to a
54
 
    particular revision of the file.  In that case the text_sha1,
55
 
    text_size and text_id are absent.
56
 
 
 
48
    file_id
 
49
 
 
50
    name
 
51
        (within the parent directory)
 
52
 
 
53
    parent_id
 
54
        file_id of the parent directory, or ROOT_ID
 
55
 
 
56
    revision
 
57
        the revision_id in which this variation of this file was 
 
58
        introduced.
 
59
 
 
60
    executable
 
61
        Indicates that this file should be executable on systems
 
62
        that support it.
 
63
 
 
64
    text_sha1
 
65
        sha-1 of the text of the file
 
66
        
 
67
    text_size
 
68
        size in bytes of the text of the file
 
69
        
 
70
    (reading a version 4 tree created a text_id field.)
57
71
 
58
72
    >>> i = Inventory()
59
73
    >>> i.path2id('')
60
 
    >>> i.add(InventoryEntry('123', 'src', kind='directory'))
61
 
    >>> i.add(InventoryEntry('2323', 'hello.c', parent_id='123'))
 
74
    'TREE_ROOT'
 
75
    >>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
 
76
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT')
 
77
    >>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
 
78
    InventoryFile('2323', 'hello.c', parent_id='123')
62
79
    >>> for j in i.iter_entries():
63
80
    ...   print j
64
81
    ... 
65
 
    ('src', InventoryEntry('123', 'src', kind='directory', parent_id=None))
66
 
    ('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
67
 
    >>> i.add(InventoryEntry('2323', 'bye.c', parent_id='123'))
 
82
    ('src', InventoryDirectory('123', 'src', parent_id='TREE_ROOT'))
 
83
    ('src/hello.c', InventoryFile('2323', 'hello.c', parent_id='123'))
 
84
    >>> i.add(InventoryFile('2323', 'bye.c', '123'))
68
85
    Traceback (most recent call last):
69
86
    ...
70
 
    BzrError: ('inventory already contains entry with id {2323}', [])
71
 
    >>> i.add(InventoryEntry('2324', 'bye.c', parent_id='123'))
72
 
    >>> i.add(InventoryEntry('2325', 'wibble', parent_id='123', kind='directory'))
 
87
    BzrError: inventory already contains entry with id {2323}
 
88
    >>> i.add(InventoryFile('2324', 'bye.c', '123'))
 
89
    InventoryFile('2324', 'bye.c', parent_id='123')
 
90
    >>> i.add(InventoryDirectory('2325', 'wibble', '123'))
 
91
    InventoryDirectory('2325', 'wibble', parent_id='123')
73
92
    >>> i.path2id('src/wibble')
74
93
    '2325'
75
94
    >>> '2325' in i
76
95
    True
77
 
    >>> i.add(InventoryEntry('2326', 'wibble.c', parent_id='2325'))
 
96
    >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
 
97
    InventoryFile('2326', 'wibble.c', parent_id='2325')
78
98
    >>> i['2326']
79
 
    InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
80
 
    >>> for j in i.iter_entries():
81
 
    ...     print j[0]
82
 
    ...     assert i.path2id(j[0])
 
99
    InventoryFile('2326', 'wibble.c', parent_id='2325')
 
100
    >>> for path, entry in i.iter_entries():
 
101
    ...     print path.replace('\\\\', '/')     # for win32 os.sep
 
102
    ...     assert i.path2id(path)
83
103
    ... 
84
104
    src
85
105
    src/bye.c
86
106
    src/hello.c
87
107
    src/wibble
88
108
    src/wibble/wibble.c
89
 
    >>> i.id2path('2326')
 
109
    >>> i.id2path('2326').replace('\\\\', '/')
90
110
    'src/wibble/wibble.c'
91
 
 
92
 
    :todo: Maybe also keep the full path of the entry, and the children?
93
 
           But those depend on its position within a particular inventory, and
94
 
           it would be nice not to need to hold the backpointer here.
95
111
    """
96
 
    def __init__(self, file_id, name, kind='file', text_id=None,
97
 
                 parent_id=None):
 
112
    
 
113
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
 
114
                 'text_id', 'parent_id', 'children', 'executable', 
 
115
                 'revision']
 
116
 
 
117
    def _add_text_to_weave(self, new_lines, parents, weave_store, transaction):
 
118
        weave_store.add_text(self.file_id, self.revision, new_lines, parents,
 
119
                             transaction)
 
120
 
 
121
    def detect_changes(self, old_entry):
 
122
        """Return a (text_modified, meta_modified) from this to old_entry.
 
123
        
 
124
        _read_tree_state must have been called on self and old_entry prior to 
 
125
        calling detect_changes.
 
126
        """
 
127
        return False, False
 
128
 
 
129
    def diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
130
             output_to, reverse=False):
 
131
        """Perform a diff from this to to_entry.
 
132
 
 
133
        text_diff will be used for textual difference calculation.
 
134
        This is a template method, override _diff in child classes.
 
135
        """
 
136
        self._read_tree_state(tree)
 
137
        if to_entry:
 
138
            # cannot diff from one kind to another - you must do a removal
 
139
            # and an addif they do not match.
 
140
            assert self.kind == to_entry.kind
 
141
            to_entry._read_tree_state(to_tree)
 
142
        self._diff(text_diff, from_label, tree, to_label, to_entry, to_tree,
 
143
                   output_to, reverse)
 
144
 
 
145
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
146
             output_to, reverse=False):
 
147
        """Perform a diff between two entries of the same kind."""
 
148
 
 
149
    def find_previous_heads(self, previous_inventories, entry_weave):
 
150
        """Return the revisions and entries that directly preceed this.
 
151
 
 
152
        Returned as a map from revision to inventory entry.
 
153
 
 
154
        This is a map containing the file revisions in all parents
 
155
        for which the file exists, and its revision is not a parent of
 
156
        any other. If the file is new, the set will be empty.
 
157
        """
 
158
        def get_ancestors(weave, entry):
 
159
            return set(map(weave.idx_to_name,
 
160
                           weave.inclusions([weave.lookup(entry.revision)])))
 
161
        heads = {}
 
162
        head_ancestors = {}
 
163
        for inv in previous_inventories:
 
164
            if self.file_id in inv:
 
165
                ie = inv[self.file_id]
 
166
                assert ie.file_id == self.file_id
 
167
                if ie.revision in heads:
 
168
                    # fixup logic, there was a bug in revision updates.
 
169
                    # with x bit support.
 
170
                    try:
 
171
                        if heads[ie.revision].executable != ie.executable:
 
172
                            heads[ie.revision].executable = False
 
173
                            ie.executable = False
 
174
                    except AttributeError:
 
175
                        pass
 
176
                    assert heads[ie.revision] == ie
 
177
                else:
 
178
                    # may want to add it.
 
179
                    # may already be covered:
 
180
                    already_present = 0 != len(
 
181
                        [head for head in heads 
 
182
                         if ie.revision in head_ancestors[head]])
 
183
                    if already_present:
 
184
                        # an ancestor of a known head.
 
185
                        continue
 
186
                    # definately a head:
 
187
                    ancestors = get_ancestors(entry_weave, ie)
 
188
                    # may knock something else out:
 
189
                    check_heads = list(heads.keys())
 
190
                    for head in check_heads:
 
191
                        if head in ancestors:
 
192
                            # this head is not really a head
 
193
                            heads.pop(head)
 
194
                    head_ancestors[ie.revision] = ancestors
 
195
                    heads[ie.revision] = ie
 
196
        return heads
 
197
 
 
198
    def get_tar_item(self, root, dp, now, tree):
 
199
        """Get a tarfile item and a file stream for its content."""
 
200
        item = tarfile.TarInfo(os.path.join(root, dp))
 
201
        # TODO: would be cool to actually set it to the timestamp of the
 
202
        # revision it was last changed
 
203
        item.mtime = now
 
204
        fileobj = self._put_in_tar(item, tree)
 
205
        return item, fileobj
 
206
 
 
207
    def has_text(self):
 
208
        """Return true if the object this entry represents has textual data.
 
209
 
 
210
        Note that textual data includes binary content.
 
211
 
 
212
        Also note that all entries get weave files created for them.
 
213
        This attribute is primarily used when upgrading from old trees that
 
214
        did not have the weave index for all inventory entries.
 
215
        """
 
216
        return False
 
217
 
 
218
    def __init__(self, file_id, name, parent_id, text_id=None):
98
219
        """Create an InventoryEntry
99
220
        
100
221
        The filename must be a single component, relative to the
101
222
        parent directory; it cannot be a whole path or relative name.
102
223
 
103
 
        >>> e = InventoryEntry('123', 'hello.c')
 
224
        >>> e = InventoryFile('123', 'hello.c', ROOT_ID)
104
225
        >>> e.name
105
226
        'hello.c'
106
227
        >>> e.file_id
107
228
        '123'
108
 
        >>> e = InventoryEntry('123', 'src/hello.c')
 
229
        >>> e = InventoryFile('123', 'src/hello.c', ROOT_ID)
109
230
        Traceback (most recent call last):
110
 
        BzrError: ("InventoryEntry name is not a simple filename: 'src/hello.c'", [])
 
231
        BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
111
232
        """
112
 
        
113
 
        if len(splitpath(name)) != 1:
114
 
            bailout('InventoryEntry name is not a simple filename: %r'
115
 
                    % name)
116
 
        
 
233
        assert isinstance(name, basestring), name
 
234
        if '/' in name or '\\' in name:
 
235
            raise BzrCheckError('InventoryEntry name %r is invalid' % name)
 
236
        
 
237
        self.executable = False
 
238
        self.revision = None
 
239
        self.text_sha1 = None
 
240
        self.text_size = None
117
241
        self.file_id = file_id
118
242
        self.name = name
119
 
        assert kind in ['file', 'directory']
120
 
        self.kind = kind
121
243
        self.text_id = text_id
122
244
        self.parent_id = parent_id
123
 
        self.text_sha1 = None
124
 
        self.text_size = None
 
245
        self.symlink_target = None
 
246
 
 
247
    def kind_character(self):
 
248
        """Return a short kind indicator useful for appending to names."""
 
249
        raise BzrError('unknown kind %r' % self.kind)
 
250
 
 
251
    known_kinds = ('file', 'directory', 'symlink', 'root_directory')
 
252
 
 
253
    def _put_in_tar(self, item, tree):
 
254
        """populate item for stashing in a tar, and return the content stream.
 
255
 
 
256
        If no content is available, return None.
 
257
        """
 
258
        raise BzrError("don't know how to export {%s} of kind %r" %
 
259
                       (self.file_id, self.kind))
 
260
 
 
261
    def put_on_disk(self, dest, dp, tree):
 
262
        """Create a representation of self on disk in the prefix dest.
 
263
        
 
264
        This is a template method - implement _put_on_disk in subclasses.
 
265
        """
 
266
        fullpath = appendpath(dest, dp)
 
267
        self._put_on_disk(fullpath, tree)
 
268
        mutter("  export {%s} kind %s to %s" % (self.file_id, self.kind, fullpath))
 
269
 
 
270
    def _put_on_disk(self, fullpath, tree):
 
271
        """Put this entry onto disk at fullpath, from tree tree."""
 
272
        raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
 
273
 
 
274
    def sorted_children(self):
 
275
        l = self.children.items()
 
276
        l.sort()
 
277
        return l
 
278
 
 
279
    @staticmethod
 
280
    def versionable_kind(kind):
 
281
        return kind in ('file', 'directory', 'symlink')
 
282
 
 
283
    def check(self, checker, rev_id, inv, tree):
 
284
        """Check this inventory entry is intact.
 
285
 
 
286
        This is a template method, override _check for kind specific
 
287
        tests.
 
288
        """
 
289
        if self.parent_id != None:
 
290
            if not inv.has_id(self.parent_id):
 
291
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
 
292
                        % (self.parent_id, rev_id))
 
293
        self._check(checker, rev_id, tree)
 
294
 
 
295
    def _check(self, checker, rev_id, tree):
 
296
        """Check this inventory entry for kind specific errors."""
 
297
        raise BzrCheckError('unknown entry kind %r in revision {%s}' % 
 
298
                            (self.kind, rev_id))
125
299
 
126
300
 
127
301
    def copy(self):
128
 
        other = InventoryEntry(self.file_id, self.name, self.kind,
129
 
                               self.text_id, self.parent_id)
130
 
        other.text_sha1 = self.text_sha1
131
 
        other.text_size = self.text_size
132
 
        return other
 
302
        """Clone this inventory entry."""
 
303
        raise NotImplementedError
133
304
 
 
305
    def _get_snapshot_change(self, previous_entries):
 
306
        if len(previous_entries) > 1:
 
307
            return 'merged'
 
308
        elif len(previous_entries) == 0:
 
309
            return 'added'
 
310
        else:
 
311
            return 'modified/renamed/reparented'
134
312
 
135
313
    def __repr__(self):
136
 
        return ("%s(%r, %r, kind=%r, parent_id=%r)"
 
314
        return ("%s(%r, %r, parent_id=%r)"
137
315
                % (self.__class__.__name__,
138
316
                   self.file_id,
139
317
                   self.name,
140
 
                   self.kind,
141
318
                   self.parent_id))
142
319
 
143
 
    
144
 
    def to_element(self):
145
 
        """Convert to XML element"""
146
 
        e = Element('entry')
147
 
 
148
 
        e.set('name', self.name)
149
 
        e.set('file_id', self.file_id)
150
 
        e.set('kind', self.kind)
151
 
 
152
 
        if self.text_size is not None:
153
 
            e.set('text_size', '%d' % self.text_size)
154
 
            
155
 
        for f in ['text_id', 'text_sha1', 'parent_id']:
156
 
            v = getattr(self, f)
157
 
            if v is not None:
158
 
                e.set(f, v)
159
 
 
160
 
        e.tail = '\n'
161
 
            
162
 
        return e
163
 
 
164
 
 
165
 
    def from_element(cls, elt):
166
 
        assert elt.tag == 'entry'
167
 
        self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'))
168
 
        self.text_id = elt.get('text_id')
169
 
        self.text_sha1 = elt.get('text_sha1')
170
 
        self.parent_id = elt.get('parent_id')
171
 
        
172
 
        ## mutter("read inventoryentry: %r" % (elt.attrib))
173
 
 
174
 
        v = elt.get('text_size')
175
 
        self.text_size = v and int(v)
176
 
 
177
 
        return self
178
 
            
179
 
 
180
 
    from_element = classmethod(from_element)
181
 
 
182
 
    def __cmp__(self, other):
183
 
        if self is other:
184
 
            return 0
 
320
    def snapshot(self, revision, path, previous_entries,
 
321
                 work_tree, weave_store, transaction):
 
322
        """Make a snapshot of this entry which may or may not have changed.
 
323
        
 
324
        This means that all its fields are populated, that it has its
 
325
        text stored in the text store or weave.
 
326
        """
 
327
        mutter('new parents of %s are %r', path, previous_entries)
 
328
        self._read_tree_state(work_tree)
 
329
        if len(previous_entries) == 1:
 
330
            # cannot be unchanged unless there is only one parent file rev.
 
331
            parent_ie = previous_entries.values()[0]
 
332
            if self._unchanged(parent_ie):
 
333
                mutter("found unchanged entry")
 
334
                self.revision = parent_ie.revision
 
335
                return "unchanged"
 
336
        return self.snapshot_revision(revision, previous_entries, 
 
337
                                      work_tree, weave_store, transaction)
 
338
 
 
339
    def snapshot_revision(self, revision, previous_entries, work_tree,
 
340
                          weave_store, transaction):
 
341
        """Record this revision unconditionally."""
 
342
        mutter('new revision for {%s}', self.file_id)
 
343
        self.revision = revision
 
344
        change = self._get_snapshot_change(previous_entries)
 
345
        self._snapshot_text(previous_entries, work_tree, weave_store,
 
346
                            transaction)
 
347
        return change
 
348
 
 
349
    def _snapshot_text(self, file_parents, work_tree, weave_store, transaction): 
 
350
        """Record the 'text' of this entry, whatever form that takes.
 
351
        
 
352
        This default implementation simply adds an empty text.
 
353
        """
 
354
        mutter('storing file {%s} in revision {%s}',
 
355
               self.file_id, self.revision)
 
356
        self._add_text_to_weave([], file_parents, weave_store, transaction)
 
357
 
 
358
    def __eq__(self, other):
185
359
        if not isinstance(other, InventoryEntry):
186
360
            return NotImplemented
187
361
 
188
 
        return cmp(self.file_id, other.file_id) \
189
 
               or cmp(self.name, other.name) \
190
 
               or cmp(self.text_sha1, other.text_sha1) \
191
 
               or cmp(self.text_size, other.text_size) \
192
 
               or cmp(self.text_id, other.text_id) \
193
 
               or cmp(self.parent_id, other.parent_id) \
194
 
               or cmp(self.kind, other.kind)
195
 
 
196
 
 
197
 
 
198
 
class Inventory(XMLMixin):
 
362
        return ((self.file_id == other.file_id)
 
363
                and (self.name == other.name)
 
364
                and (other.symlink_target == self.symlink_target)
 
365
                and (self.text_sha1 == other.text_sha1)
 
366
                and (self.text_size == other.text_size)
 
367
                and (self.text_id == other.text_id)
 
368
                and (self.parent_id == other.parent_id)
 
369
                and (self.kind == other.kind)
 
370
                and (self.revision == other.revision)
 
371
                and (self.executable == other.executable)
 
372
                )
 
373
 
 
374
    def __ne__(self, other):
 
375
        return not (self == other)
 
376
 
 
377
    def __hash__(self):
 
378
        raise ValueError('not hashable')
 
379
 
 
380
    def _unchanged(self, previous_ie):
 
381
        """Has this entry changed relative to previous_ie.
 
382
 
 
383
        This method should be overriden in child classes.
 
384
        """
 
385
        compatible = True
 
386
        # different inv parent
 
387
        if previous_ie.parent_id != self.parent_id:
 
388
            compatible = False
 
389
        # renamed
 
390
        elif previous_ie.name != self.name:
 
391
            compatible = False
 
392
        return compatible
 
393
 
 
394
    def _read_tree_state(self, work_tree):
 
395
        """Populate fields in the inventory entry from the given tree.
 
396
        
 
397
        Note that this should be modified to be a noop on virtual trees
 
398
        as all entries created there are prepopulated.
 
399
        """
 
400
        # TODO: Rather than running this manually, we should check the 
 
401
        # working sha1 and other expensive properties when they're
 
402
        # first requested, or preload them if they're already known
 
403
        pass            # nothing to do by default
 
404
 
 
405
 
 
406
class RootEntry(InventoryEntry):
 
407
 
 
408
    def _check(self, checker, rev_id, tree):
 
409
        """See InventoryEntry._check"""
 
410
 
 
411
    def __init__(self, file_id):
 
412
        self.file_id = file_id
 
413
        self.children = {}
 
414
        self.kind = 'root_directory'
 
415
        self.parent_id = None
 
416
        self.name = ''
 
417
 
 
418
    def __eq__(self, other):
 
419
        if not isinstance(other, RootEntry):
 
420
            return NotImplemented
 
421
        
 
422
        return (self.file_id == other.file_id) \
 
423
               and (self.children == other.children)
 
424
 
 
425
 
 
426
class InventoryDirectory(InventoryEntry):
 
427
    """A directory in an inventory."""
 
428
 
 
429
    def _check(self, checker, rev_id, tree):
 
430
        """See InventoryEntry._check"""
 
431
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
 
432
            raise BzrCheckError('directory {%s} has text in revision {%s}'
 
433
                                % (self.file_id, rev_id))
 
434
 
 
435
    def copy(self):
 
436
        other = InventoryDirectory(self.file_id, self.name, self.parent_id)
 
437
        other.revision = self.revision
 
438
        # note that children are *not* copied; they're pulled across when
 
439
        # others are added
 
440
        return other
 
441
 
 
442
    def __init__(self, file_id, name, parent_id):
 
443
        super(InventoryDirectory, self).__init__(file_id, name, parent_id)
 
444
        self.children = {}
 
445
        self.kind = 'directory'
 
446
 
 
447
    def kind_character(self):
 
448
        """See InventoryEntry.kind_character."""
 
449
        return '/'
 
450
 
 
451
    def _put_in_tar(self, item, tree):
 
452
        """See InventoryEntry._put_in_tar."""
 
453
        item.type = tarfile.DIRTYPE
 
454
        fileobj = None
 
455
        item.name += '/'
 
456
        item.size = 0
 
457
        item.mode = 0755
 
458
        return fileobj
 
459
 
 
460
    def _put_on_disk(self, fullpath, tree):
 
461
        """See InventoryEntry._put_on_disk."""
 
462
        os.mkdir(fullpath)
 
463
 
 
464
 
 
465
class InventoryFile(InventoryEntry):
 
466
    """A file in an inventory."""
 
467
 
 
468
    def _check(self, checker, rev_id, tree):
 
469
        """See InventoryEntry._check"""
 
470
        revision = self.revision
 
471
        t = (self.file_id, revision)
 
472
        if t in checker.checked_texts:
 
473
            prev_sha = checker.checked_texts[t] 
 
474
            if prev_sha != self.text_sha1:
 
475
                raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
 
476
                                    (self.file_id, rev_id))
 
477
            else:
 
478
                checker.repeated_text_cnt += 1
 
479
                return
 
480
        mutter('check version {%s} of {%s}', rev_id, self.file_id)
 
481
        file_lines = tree.get_file_lines(self.file_id)
 
482
        checker.checked_text_cnt += 1 
 
483
        if self.text_size != sum(map(len, file_lines)):
 
484
            raise BzrCheckError('text {%s} wrong size' % self.text_id)
 
485
        if self.text_sha1 != sha_strings(file_lines):
 
486
            raise BzrCheckError('text {%s} wrong sha1' % self.text_id)
 
487
        checker.checked_texts[t] = self.text_sha1
 
488
 
 
489
    def copy(self):
 
490
        other = InventoryFile(self.file_id, self.name, self.parent_id)
 
491
        other.executable = self.executable
 
492
        other.text_id = self.text_id
 
493
        other.text_sha1 = self.text_sha1
 
494
        other.text_size = self.text_size
 
495
        other.revision = self.revision
 
496
        return other
 
497
 
 
498
    def detect_changes(self, old_entry):
 
499
        """See InventoryEntry.detect_changes."""
 
500
        assert self.text_sha1 != None
 
501
        assert old_entry.text_sha1 != None
 
502
        text_modified = (self.text_sha1 != old_entry.text_sha1)
 
503
        meta_modified = (self.executable != old_entry.executable)
 
504
        return text_modified, meta_modified
 
505
 
 
506
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
507
             output_to, reverse=False):
 
508
        """See InventoryEntry._diff."""
 
509
        from_text = tree.get_file(self.file_id).readlines()
 
510
        if to_entry:
 
511
            to_text = to_tree.get_file(to_entry.file_id).readlines()
 
512
        else:
 
513
            to_text = []
 
514
        if not reverse:
 
515
            text_diff(from_label, from_text,
 
516
                      to_label, to_text, output_to)
 
517
        else:
 
518
            text_diff(to_label, to_text,
 
519
                      from_label, from_text, output_to)
 
520
 
 
521
    def has_text(self):
 
522
        """See InventoryEntry.has_text."""
 
523
        return True
 
524
 
 
525
    def __init__(self, file_id, name, parent_id):
 
526
        super(InventoryFile, self).__init__(file_id, name, parent_id)
 
527
        self.kind = 'file'
 
528
 
 
529
    def kind_character(self):
 
530
        """See InventoryEntry.kind_character."""
 
531
        return ''
 
532
 
 
533
    def _put_in_tar(self, item, tree):
 
534
        """See InventoryEntry._put_in_tar."""
 
535
        item.type = tarfile.REGTYPE
 
536
        fileobj = tree.get_file(self.file_id)
 
537
        item.size = self.text_size
 
538
        if tree.is_executable(self.file_id):
 
539
            item.mode = 0755
 
540
        else:
 
541
            item.mode = 0644
 
542
        return fileobj
 
543
 
 
544
    def _put_on_disk(self, fullpath, tree):
 
545
        """See InventoryEntry._put_on_disk."""
 
546
        pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
 
547
        if tree.is_executable(self.file_id):
 
548
            os.chmod(fullpath, 0755)
 
549
 
 
550
    def _read_tree_state(self, work_tree):
 
551
        """See InventoryEntry._read_tree_state."""
 
552
        self.text_sha1 = work_tree.get_file_sha1(self.file_id)
 
553
        self.executable = work_tree.is_executable(self.file_id)
 
554
 
 
555
    def _snapshot_text(self, file_parents, work_tree, weave_store, transaction):
 
556
        """See InventoryEntry._snapshot_text."""
 
557
        mutter('storing file {%s} in revision {%s}',
 
558
               self.file_id, self.revision)
 
559
        # special case to avoid diffing on renames or 
 
560
        # reparenting
 
561
        if (len(file_parents) == 1
 
562
            and self.text_sha1 == file_parents.values()[0].text_sha1
 
563
            and self.text_size == file_parents.values()[0].text_size):
 
564
            previous_ie = file_parents.values()[0]
 
565
            weave_store.add_identical_text(
 
566
                self.file_id, previous_ie.revision, 
 
567
                self.revision, file_parents, transaction)
 
568
        else:
 
569
            new_lines = work_tree.get_file(self.file_id).readlines()
 
570
            self._add_text_to_weave(new_lines, file_parents, weave_store,
 
571
                                    transaction)
 
572
            self.text_sha1 = sha_strings(new_lines)
 
573
            self.text_size = sum(map(len, new_lines))
 
574
 
 
575
 
 
576
    def _unchanged(self, previous_ie):
 
577
        """See InventoryEntry._unchanged."""
 
578
        compatible = super(InventoryFile, self)._unchanged(previous_ie)
 
579
        if self.text_sha1 != previous_ie.text_sha1:
 
580
            compatible = False
 
581
        else:
 
582
            # FIXME: 20050930 probe for the text size when getting sha1
 
583
            # in _read_tree_state
 
584
            self.text_size = previous_ie.text_size
 
585
        if self.executable != previous_ie.executable:
 
586
            compatible = False
 
587
        return compatible
 
588
 
 
589
 
 
590
class InventoryLink(InventoryEntry):
 
591
    """A file in an inventory."""
 
592
 
 
593
    __slots__ = ['symlink_target']
 
594
 
 
595
    def _check(self, checker, rev_id, tree):
 
596
        """See InventoryEntry._check"""
 
597
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
 
598
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
 
599
                    % (self.file_id, rev_id))
 
600
        if self.symlink_target == None:
 
601
            raise BzrCheckError('symlink {%s} has no target in revision {%s}'
 
602
                    % (self.file_id, rev_id))
 
603
 
 
604
    def copy(self):
 
605
        other = InventoryLink(self.file_id, self.name, self.parent_id)
 
606
        other.symlink_target = self.symlink_target
 
607
        other.revision = self.revision
 
608
        return other
 
609
 
 
610
    def detect_changes(self, old_entry):
 
611
        """See InventoryEntry.detect_changes."""
 
612
        # FIXME: which _modified field should we use ? RBC 20051003
 
613
        text_modified = (self.symlink_target != old_entry.symlink_target)
 
614
        if text_modified:
 
615
            mutter("    symlink target changed")
 
616
        meta_modified = False
 
617
        return text_modified, meta_modified
 
618
 
 
619
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
620
             output_to, reverse=False):
 
621
        """See InventoryEntry._diff."""
 
622
        from_text = self.symlink_target
 
623
        if to_entry is not None:
 
624
            to_text = to_entry.symlink_target
 
625
            if reverse:
 
626
                temp = from_text
 
627
                from_text = to_text
 
628
                to_text = temp
 
629
            print >>output_to, '=== target changed %r => %r' % (from_text, to_text)
 
630
        else:
 
631
            if not reverse:
 
632
                print >>output_to, '=== target was %r' % self.symlink_target
 
633
            else:
 
634
                print >>output_to, '=== target is %r' % self.symlink_target
 
635
 
 
636
    def __init__(self, file_id, name, parent_id):
 
637
        super(InventoryLink, self).__init__(file_id, name, parent_id)
 
638
        self.kind = 'symlink'
 
639
 
 
640
    def kind_character(self):
 
641
        """See InventoryEntry.kind_character."""
 
642
        return ''
 
643
 
 
644
    def _put_in_tar(self, item, tree):
 
645
        """See InventoryEntry._put_in_tar."""
 
646
        iterm.type = tarfile.SYMTYPE
 
647
        fileobj = None
 
648
        item.size = 0
 
649
        item.mode = 0755
 
650
        item.linkname = self.symlink_target
 
651
        return fileobj
 
652
 
 
653
    def _put_on_disk(self, fullpath, tree):
 
654
        """See InventoryEntry._put_on_disk."""
 
655
        try:
 
656
            os.symlink(self.symlink_target, fullpath)
 
657
        except OSError,e:
 
658
            raise BzrError("Failed to create symlink %r -> %r, error: %s" % (fullpath, self.symlink_target, e))
 
659
 
 
660
    def _read_tree_state(self, work_tree):
 
661
        """See InventoryEntry._read_tree_state."""
 
662
        self.symlink_target = work_tree.get_symlink_target(self.file_id)
 
663
 
 
664
    def _unchanged(self, previous_ie):
 
665
        """See InventoryEntry._unchanged."""
 
666
        compatible = super(InventoryLink, self)._unchanged(previous_ie)
 
667
        if self.symlink_target != previous_ie.symlink_target:
 
668
            compatible = False
 
669
        return compatible
 
670
 
 
671
 
 
672
class Inventory(object):
199
673
    """Inventory of versioned files in a tree.
200
674
 
201
 
    An Inventory acts like a set of InventoryEntry items.  You can
202
 
    also look files up by their file_id or name.
203
 
    
204
 
    May be read from and written to a metadata file in a tree.  To
205
 
    manipulate the inventory (for example to add a file), it is read
206
 
    in, modified, and then written back out.
 
675
    This describes which file_id is present at each point in the tree,
 
676
    and possibly the SHA-1 or other information about the file.
 
677
    Entries can be looked up either by path or by file_id.
207
678
 
208
679
    The inventory represents a typical unix file tree, with
209
680
    directories containing files and subdirectories.  We never store
213
684
    returned quickly.
214
685
 
215
686
    InventoryEntry objects must not be modified after they are
216
 
    inserted.
 
687
    inserted, other than through the Inventory API.
217
688
 
218
689
    >>> inv = Inventory()
219
 
    >>> inv.write_xml(sys.stdout)
220
 
    <inventory>
221
 
    </inventory>
222
 
    >>> inv.add(InventoryEntry('123-123', 'hello.c'))
 
690
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
 
691
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
223
692
    >>> inv['123-123'].name
224
693
    'hello.c'
225
 
    >>> for file_id in inv: print file_id
226
 
    ...
227
 
    123-123
228
694
 
229
695
    May be treated as an iterator or set to look up file ids:
230
696
    
237
703
 
238
704
    >>> [x[0] for x in inv.iter_entries()]
239
705
    ['hello.c']
240
 
    
241
 
    >>> inv.write_xml(sys.stdout)
242
 
    <inventory>
243
 
    <entry file_id="123-123" kind="file" name="hello.c" />
244
 
    </inventory>
245
 
 
 
706
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
 
707
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
 
708
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
246
709
    """
247
 
 
248
 
    ## TODO: Clear up handling of files in subdirectories; we probably
249
 
    ## do want to be able to just look them up by name but this
250
 
    ## probably means gradually walking down the path, looking up as we go.
251
 
 
252
 
    ## TODO: Make sure only canonical filenames are stored.
253
 
 
254
 
    ## TODO: Do something sensible about the possible collisions on
255
 
    ## case-losing filesystems.  Perhaps we should just always forbid
256
 
    ## such collisions.
257
 
 
258
 
    ## _tree should probably just be stored as
259
 
    ## InventoryEntry._children on each directory.
260
 
 
261
 
    def __init__(self):
 
710
    def __init__(self, root_id=ROOT_ID):
262
711
        """Create or read an inventory.
263
712
 
264
713
        If a working directory is specified, the inventory is read
265
714
        from there.  If the file is specified, read from that. If not,
266
715
        the inventory is created empty.
 
716
 
 
717
        The inventory is created with a default root directory, with
 
718
        an id of None.
267
719
        """
268
 
        self._byid = dict()
269
 
 
270
 
        # _tree is indexed by parent_id; at each level a map from name
271
 
        # to ie.  The None entry is the root.
272
 
        self._tree = {None: {}}
 
720
        # We are letting Branch.initialize() create a unique inventory
 
721
        # root id. Rather than generating a random one here.
 
722
        #if root_id is None:
 
723
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
 
724
        self.root = RootEntry(root_id)
 
725
        self._byid = {self.root.file_id: self.root}
 
726
 
 
727
 
 
728
    def copy(self):
 
729
        other = Inventory(self.root.file_id)
 
730
        # copy recursively so we know directories will be added before
 
731
        # their children.  There are more efficient ways than this...
 
732
        for path, entry in self.iter_entries():
 
733
            if entry == self.root:
 
734
                continue
 
735
            other.add(entry.copy())
 
736
        return other
273
737
 
274
738
 
275
739
    def __iter__(self):
281
745
        return len(self._byid)
282
746
 
283
747
 
284
 
    def iter_entries(self, parent_id=None):
 
748
    def iter_entries(self, from_dir=None):
285
749
        """Return (path, entry) pairs, in order by name."""
286
 
        kids = self._tree[parent_id].items()
 
750
        if from_dir == None:
 
751
            assert self.root
 
752
            from_dir = self.root
 
753
        elif isinstance(from_dir, basestring):
 
754
            from_dir = self._byid[from_dir]
 
755
            
 
756
        kids = from_dir.children.items()
287
757
        kids.sort()
288
758
        for name, ie in kids:
289
759
            yield name, ie
290
760
            if ie.kind == 'directory':
291
 
                for cn, cie in self.iter_entries(parent_id=ie.file_id):
292
 
                    yield joinpath([name, cn]), cie
293
 
 
294
 
 
295
 
    def directories(self, include_root=True):
296
 
        """Return (path, entry) pairs for all directories.
297
 
        """
298
 
        if include_root:
299
 
            yield '', None
300
 
        for path, entry in self.iter_entries():
301
 
            if entry.kind == 'directory':
302
 
                yield path, entry
 
761
                for cn, cie in self.iter_entries(from_dir=ie.file_id):
 
762
                    yield os.path.join(name, cn), cie
 
763
 
 
764
 
 
765
    def entries(self):
 
766
        """Return list of (path, ie) for all entries except the root.
 
767
 
 
768
        This may be faster than iter_entries.
 
769
        """
 
770
        accum = []
 
771
        def descend(dir_ie, dir_path):
 
772
            kids = dir_ie.children.items()
 
773
            kids.sort()
 
774
            for name, ie in kids:
 
775
                child_path = os.path.join(dir_path, name)
 
776
                accum.append((child_path, ie))
 
777
                if ie.kind == 'directory':
 
778
                    descend(ie, child_path)
 
779
 
 
780
        descend(self.root, '')
 
781
        return accum
 
782
 
 
783
 
 
784
    def directories(self):
 
785
        """Return (path, entry) pairs for all directories, including the root.
 
786
        """
 
787
        accum = []
 
788
        def descend(parent_ie, parent_path):
 
789
            accum.append((parent_path, parent_ie))
 
790
            
 
791
            kids = [(ie.name, ie) for ie in parent_ie.children.itervalues() if ie.kind == 'directory']
 
792
            kids.sort()
 
793
 
 
794
            for name, child_ie in kids:
 
795
                child_path = os.path.join(parent_path, name)
 
796
                descend(child_ie, child_path)
 
797
        descend(self.root, '')
 
798
        return accum
303
799
        
304
800
 
305
801
 
306
 
    def children(self, parent_id):
307
 
        """Return entries that are direct children of parent_id."""
308
 
        return self._tree[parent_id]
309
 
                    
310
 
 
311
 
 
312
 
    # TODO: return all paths and entries
313
 
 
314
 
 
315
802
    def __contains__(self, file_id):
316
803
        """True if this entry contains a file with given id.
317
804
 
318
805
        >>> inv = Inventory()
319
 
        >>> inv.add(InventoryEntry('123', 'foo.c'))
 
806
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
 
807
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
320
808
        >>> '123' in inv
321
809
        True
322
810
        >>> '456' in inv
329
817
        """Return the entry for given file_id.
330
818
 
331
819
        >>> inv = Inventory()
332
 
        >>> inv.add(InventoryEntry('123123', 'hello.c'))
 
820
        >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
 
821
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
333
822
        >>> inv['123123'].name
334
823
        'hello.c'
335
824
        """
336
 
        return self._byid[file_id]
 
825
        try:
 
826
            return self._byid[file_id]
 
827
        except KeyError:
 
828
            if file_id == None:
 
829
                raise BzrError("can't look up file_id None")
 
830
            else:
 
831
                raise BzrError("file_id {%s} not in inventory" % file_id)
 
832
 
 
833
 
 
834
    def get_file_kind(self, file_id):
 
835
        return self._byid[file_id].kind
 
836
 
 
837
    def get_child(self, parent_id, filename):
 
838
        return self[parent_id].children.get(filename)
337
839
 
338
840
 
339
841
    def add(self, entry):
340
842
        """Add entry to inventory.
341
843
 
342
844
        To add  a file to a branch ready to be committed, use Branch.add,
343
 
        which calls this."""
344
 
        if entry.file_id in self:
345
 
            bailout("inventory already contains entry with id {%s}" % entry.file_id)
346
 
 
347
 
        if entry.parent_id != None:
348
 
            if entry.parent_id not in self:
349
 
                bailout("parent_id %s of new entry not found in inventory"
350
 
                        % entry.parent_id)
351
 
            
352
 
        if self._tree[entry.parent_id].has_key(entry.name):
353
 
            bailout("%s is already versioned"
354
 
                    % appendpath(self.id2path(entry.parent_id), entry.name))
 
845
        which calls this.
 
846
 
 
847
        Returns the new entry object.
 
848
        """
 
849
        if entry.file_id in self._byid:
 
850
            raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
 
851
 
 
852
        if entry.parent_id == ROOT_ID or entry.parent_id is None:
 
853
            entry.parent_id = self.root.file_id
 
854
 
 
855
        try:
 
856
            parent = self._byid[entry.parent_id]
 
857
        except KeyError:
 
858
            raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
 
859
 
 
860
        if parent.children.has_key(entry.name):
 
861
            raise BzrError("%s is already versioned" %
 
862
                    appendpath(self.id2path(parent.file_id), entry.name))
355
863
 
356
864
        self._byid[entry.file_id] = entry
357
 
        self._tree[entry.parent_id][entry.name] = entry
358
 
 
359
 
        if entry.kind == 'directory':
360
 
            self._tree[entry.file_id] = {}
 
865
        parent.children[entry.name] = entry
 
866
        return entry
 
867
 
 
868
 
 
869
    def add_path(self, relpath, kind, file_id=None):
 
870
        """Add entry from a path.
 
871
 
 
872
        The immediate parent must already be versioned.
 
873
 
 
874
        Returns the new entry object."""
 
875
        from bzrlib.branch import gen_file_id
 
876
        
 
877
        parts = bzrlib.osutils.splitpath(relpath)
 
878
        if len(parts) == 0:
 
879
            raise BzrError("cannot re-add root of inventory")
 
880
 
 
881
        if file_id == None:
 
882
            file_id = gen_file_id(relpath)
 
883
 
 
884
        parent_path = parts[:-1]
 
885
        parent_id = self.path2id(parent_path)
 
886
        if parent_id == None:
 
887
            raise NotVersionedError(parent_path)
 
888
 
 
889
        if kind == 'directory':
 
890
            ie = InventoryDirectory(file_id, parts[-1], parent_id)
 
891
        elif kind == 'file':
 
892
            ie = InventoryFile(file_id, parts[-1], parent_id)
 
893
        elif kind == 'symlink':
 
894
            ie = InventoryLink(file_id, parts[-1], parent_id)
 
895
        else:
 
896
            raise BzrError("unknown kind %r" % kind)
 
897
        return self.add(ie)
361
898
 
362
899
 
363
900
    def __delitem__(self, file_id):
364
901
        """Remove entry by id.
365
902
 
366
903
        >>> inv = Inventory()
367
 
        >>> inv.add(InventoryEntry('123', 'foo.c'))
 
904
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
 
905
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
368
906
        >>> '123' in inv
369
907
        True
370
908
        >>> del inv['123']
373
911
        """
374
912
        ie = self[file_id]
375
913
 
376
 
        assert self._tree[ie.parent_id][ie.name] == ie
 
914
        assert self[ie.parent_id].children[ie.name] == ie
377
915
        
378
916
        # TODO: Test deleting all children; maybe hoist to a separate
379
917
        # deltree method?
380
918
        if ie.kind == 'directory':
381
 
            for cie in self._tree[file_id].values():
 
919
            for cie in ie.children.values():
382
920
                del self[cie.file_id]
383
 
            del self._tree[file_id]
 
921
            del ie.children
384
922
 
385
923
        del self._byid[file_id]
386
 
        del self._tree[ie.parent_id][ie.name]
387
 
 
388
 
 
389
 
    def id_set(self):
390
 
        return Set(self._byid)
391
 
 
392
 
 
393
 
    def to_element(self):
394
 
        """Convert to XML Element"""
395
 
        e = Element('inventory')
396
 
        e.text = '\n'
397
 
        for path, ie in self.iter_entries():
398
 
            e.append(ie.to_element())
399
 
        return e
400
 
    
401
 
 
402
 
    def from_element(cls, elt):
403
 
        """Construct from XML Element
404
 
 
405
 
        >>> inv = Inventory()
406
 
        >>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c'))
407
 
        >>> elt = inv.to_element()
408
 
        >>> inv2 = Inventory.from_element(elt)
409
 
        >>> inv2 == inv
410
 
        True
411
 
        """
412
 
        assert elt.tag == 'inventory'
413
 
        o = cls()
414
 
        for e in elt:
415
 
            o.add(InventoryEntry.from_element(e))
416
 
        return o
417
 
        
418
 
    from_element = classmethod(from_element)
419
 
 
420
 
 
421
 
    def __cmp__(self, other):
 
924
        del self[ie.parent_id].children[ie.name]
 
925
 
 
926
 
 
927
    def __eq__(self, other):
422
928
        """Compare two sets by comparing their contents.
423
929
 
424
930
        >>> i1 = Inventory()
425
931
        >>> i2 = Inventory()
426
932
        >>> i1 == i2
427
933
        True
428
 
        >>> i1.add(InventoryEntry('123', 'foo'))
 
934
        >>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
 
935
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
429
936
        >>> i1 == i2
430
937
        False
431
 
        >>> i2.add(InventoryEntry('123', 'foo'))
 
938
        >>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
 
939
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
432
940
        >>> i1 == i2
433
941
        True
434
942
        """
435
 
        if self is other:
436
 
            return 0
437
 
        
438
943
        if not isinstance(other, Inventory):
439
944
            return NotImplemented
440
945
 
441
 
        if self.id_set() ^ other.id_set():
442
 
            return 1
443
 
 
444
 
        for file_id in self._byid:
445
 
            c = cmp(self[file_id], other[file_id])
446
 
            if c: return c
447
 
 
448
 
        return 0
449
 
 
450
 
 
451
 
    def id2path(self, file_id):
452
 
        """Return as a list the path to file_id."""
 
946
        if len(self._byid) != len(other._byid):
 
947
            # shortcut: obviously not the same
 
948
            return False
 
949
 
 
950
        return self._byid == other._byid
 
951
 
 
952
 
 
953
    def __ne__(self, other):
 
954
        return not self.__eq__(other)
 
955
 
 
956
 
 
957
    def __hash__(self):
 
958
        raise ValueError('not hashable')
 
959
 
 
960
 
 
961
    def get_idpath(self, file_id):
 
962
        """Return a list of file_ids for the path to an entry.
 
963
 
 
964
        The list contains one element for each directory followed by
 
965
        the id of the file itself.  So the length of the returned list
 
966
        is equal to the depth of the file in the tree, counting the
 
967
        root directory as depth 1.
 
968
        """
453
969
        p = []
454
970
        while file_id != None:
455
 
            ie = self[file_id]
456
 
            p = [ie.name] + p
 
971
            try:
 
972
                ie = self._byid[file_id]
 
973
            except KeyError:
 
974
                raise BzrError("file_id {%s} not found in inventory" % file_id)
 
975
            p.insert(0, ie.file_id)
457
976
            file_id = ie.parent_id
458
 
        return joinpath(p)
 
977
        return p
 
978
 
 
979
 
 
980
    def id2path(self, file_id):
 
981
        """Return as a list the path to file_id.
 
982
        
 
983
        >>> i = Inventory()
 
984
        >>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))
 
985
        >>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))
 
986
        >>> print i.id2path('foo-id').replace(os.sep, '/')
 
987
        src/foo.c
 
988
        """
 
989
        # get all names, skipping root
 
990
        p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
 
991
        return os.sep.join(p)
459
992
            
460
993
 
461
994
 
467
1000
 
468
1001
        This returns the entry of the last component in the path,
469
1002
        which may be either a file or a directory.
 
1003
 
 
1004
        Returns None iff the path is not found.
470
1005
        """
471
 
        assert isinstance(name, types.StringTypes)
472
 
 
473
 
        parent_id = None
474
 
        for f in splitpath(name):
 
1006
        if isinstance(name, types.StringTypes):
 
1007
            name = splitpath(name)
 
1008
 
 
1009
        mutter("lookup path %r" % name)
 
1010
 
 
1011
        parent = self.root
 
1012
        for f in name:
475
1013
            try:
476
 
                cie = self._tree[parent_id][f]
 
1014
                cie = parent.children[f]
477
1015
                assert cie.name == f
478
 
                parent_id = cie.file_id
 
1016
                assert cie.parent_id == parent.file_id
 
1017
                parent = cie
479
1018
            except KeyError:
480
1019
                # or raise an error?
481
1020
                return None
482
1021
 
483
 
        return parent_id
484
 
 
485
 
 
486
 
    def get_child(self, parent_id, child_name):
487
 
        return self._tree[parent_id].get(child_name)
 
1022
        return parent.file_id
488
1023
 
489
1024
 
490
1025
    def has_filename(self, names):
492
1027
 
493
1028
 
494
1029
    def has_id(self, file_id):
495
 
        assert isinstance(file_id, str)
496
1030
        return self._byid.has_key(file_id)
497
1031
 
498
1032
 
499
 
 
500
 
if __name__ == '__main__':
501
 
    import doctest, inventory
502
 
    doctest.testmod(inventory)
 
1033
    def rename(self, file_id, new_parent_id, new_name):
 
1034
        """Move a file within the inventory.
 
1035
 
 
1036
        This can change either the name, or the parent, or both.
 
1037
 
 
1038
        This does not move the working file."""
 
1039
        if not is_valid_name(new_name):
 
1040
            raise BzrError("not an acceptable filename: %r" % new_name)
 
1041
 
 
1042
        new_parent = self._byid[new_parent_id]
 
1043
        if new_name in new_parent.children:
 
1044
            raise BzrError("%r already exists in %r" % (new_name, self.id2path(new_parent_id)))
 
1045
 
 
1046
        new_parent_idpath = self.get_idpath(new_parent_id)
 
1047
        if file_id in new_parent_idpath:
 
1048
            raise BzrError("cannot move directory %r into a subdirectory of itself, %r"
 
1049
                    % (self.id2path(file_id), self.id2path(new_parent_id)))
 
1050
 
 
1051
        file_ie = self._byid[file_id]
 
1052
        old_parent = self._byid[file_ie.parent_id]
 
1053
 
 
1054
        # TODO: Don't leave things messed up if this fails
 
1055
 
 
1056
        del old_parent.children[file_ie.name]
 
1057
        new_parent.children[new_name] = file_ie
 
1058
        
 
1059
        file_ie.name = new_name
 
1060
        file_ie.parent_id = new_parent_id
 
1061
 
 
1062
 
 
1063
 
 
1064
 
 
1065
_NAME_RE = None
 
1066
 
 
1067
def is_valid_name(name):
 
1068
    global _NAME_RE
 
1069
    if _NAME_RE == None:
 
1070
        _NAME_RE = re.compile(r'^[^/\\]+$')
 
1071
        
 
1072
    return bool(_NAME_RE.match(name))