~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

Add notes on merge/review process.

Show diffs side-by-side

added added

removed removed

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