/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Robert Collins
  • Date: 2005-10-17 23:13:00 UTC
  • mto: This revision was merged to the branch mainline in revision 1462.
  • Revision ID: robertc@robertcollins.net-20051017231300-e1c9e931bcfacd6a
Branch.open_containing now returns a tuple (Branch, relative-path).

This allows direct access to the common case of 'get me this file
from its branch'. (Robert Collins)

Show diffs side-by-side

added added

removed removed

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