~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Robert Collins
  • Date: 2005-08-25 01:13:32 UTC
  • mto: (974.1.50) (1185.1.10) (1092.3.1)
  • mto: This revision was merged to the branch mainline in revision 1139.
  • Revision ID: robertc@robertcollins.net-20050825011331-6d549d5de7edcec1
two bugfixes to smart_add - do not add paths from nested trees to the parent tree, and do not mutate the user supplied file list

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.
25
17
 
26
18
# This should really be an id randomly assigned when the tree is
27
19
# created, but it's not for now.
28
20
ROOT_ID = "TREE_ROOT"
29
21
 
30
22
 
31
 
import os.path
32
 
import re
33
 
import sys
34
 
import tarfile
35
 
import types
 
23
import sys, os.path, types, re
36
24
 
37
25
import bzrlib
38
 
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
39
 
                            pathjoin, sha_strings)
 
26
from bzrlib.errors import BzrError, BzrCheckError
 
27
 
 
28
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
40
29
from bzrlib.trace import mutter
41
 
from bzrlib.errors import (NotVersionedError, InvalidEntryName,
42
 
                           BzrError, BzrCheckError)
43
 
 
 
30
from bzrlib.errors import NotVersionedError
 
31
        
44
32
 
45
33
class InventoryEntry(object):
46
34
    """Description of a versioned file.
48
36
    An InventoryEntry has the following fields, which are also
49
37
    present in the XML inventory-entry element:
50
38
 
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.)
 
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
 
74
53
 
75
54
    >>> i = Inventory()
76
55
    >>> i.path2id('')
77
56
    'TREE_ROOT'
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: pathjoin('src','hello.c')}
83
 
    >>> for ix, j in enumerate(i.iter_entries()):
84
 
    ...   print (j[0] == shouldbe[ix], j[1])
 
57
    >>> i.add(InventoryEntry('123', 'src', 'directory', ROOT_ID))
 
58
    >>> i.add(InventoryEntry('2323', 'hello.c', 'file', parent_id='123'))
 
59
    >>> for j in i.iter_entries():
 
60
    ...   print j
85
61
    ... 
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'))
 
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'))
89
65
    Traceback (most recent call last):
90
66
    ...
91
67
    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')
 
68
    >>> i.add(InventoryEntry('2324', 'bye.c', 'file', '123'))
 
69
    >>> i.add(InventoryEntry('2325', 'wibble', 'directory', '123'))
96
70
    >>> i.path2id('src/wibble')
97
71
    '2325'
98
72
    >>> '2325' in i
99
73
    True
100
 
    >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
101
 
    InventoryFile('2326', 'wibble.c', parent_id='2325')
 
74
    >>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
102
75
    >>> i['2326']
103
 
    InventoryFile('2326', 'wibble.c', parent_id='2325')
104
 
    >>> for path, entry in i.iter_entries():
105
 
    ...     print path
106
 
    ...     assert i.path2id(path)
 
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])
107
80
    ... 
108
81
    src
109
82
    src/bye.c
112
85
    src/wibble/wibble.c
113
86
    >>> i.id2path('2326')
114
87
    '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.
115
92
    """
116
 
    
 
93
 
 
94
    # TODO: split InventoryEntry into subclasses for files,
 
95
    # directories, etc etc.
 
96
 
117
97
    __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(pathjoin(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):
 
98
                 'text_id', 'parent_id', 'children', ]
 
99
 
 
100
    def __init__(self, file_id, name, kind, parent_id, text_id=None):
224
101
        """Create an InventoryEntry
225
102
        
226
103
        The filename must be a single component, relative to the
227
104
        parent directory; it cannot be a whole path or relative name.
228
105
 
229
 
        >>> e = InventoryFile('123', 'hello.c', ROOT_ID)
 
106
        >>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
230
107
        >>> e.name
231
108
        'hello.c'
232
109
        >>> e.file_id
233
110
        '123'
234
 
        >>> e = InventoryFile('123', 'src/hello.c', ROOT_ID)
 
111
        >>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
235
112
        Traceback (most recent call last):
236
 
        InvalidEntryName: Invalid entry name: src/hello.c
 
113
        BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
237
114
        """
238
 
        assert isinstance(name, basestring), name
239
115
        if '/' in name or '\\' in name:
240
 
            raise InvalidEntryName(name=name)
241
 
        self.executable = False
242
 
        self.revision = None
 
116
            raise BzrCheckError('InventoryEntry name %r is invalid' % name)
 
117
        
243
118
        self.text_sha1 = None
244
119
        self.text_size = None
 
120
    
245
121
        self.file_id = file_id
246
122
        self.name = name
 
123
        self.kind = kind
247
124
        self.text_id = text_id
248
125
        self.parent_id = parent_id
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 = pathjoin(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))
 
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
 
278
134
 
279
135
    def sorted_children(self):
280
136
        l = self.children.items()
281
137
        l.sort()
282
138
        return l
283
139
 
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
 
 
305
140
 
306
141
    def copy(self):
307
 
        """Clone this inventory entry."""
308
 
        raise NotImplementedError
 
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
309
149
 
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'
317
150
 
318
151
    def __repr__(self):
319
 
        return ("%s(%r, %r, parent_id=%r)"
 
152
        return ("%s(%r, %r, kind=%r, parent_id=%r)"
320
153
                % (self.__class__.__name__,
321
154
                   self.file_id,
322
155
                   self.name,
 
156
                   self.kind,
323
157
                   self.parent_id))
324
158
 
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)
 
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)
362
213
 
363
214
    def __eq__(self, other):
364
215
        if not isinstance(other, InventoryEntry):
365
216
            return NotImplemented
366
217
 
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
 
                )
 
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
 
378
226
 
379
227
    def __ne__(self, other):
380
228
        return not (self == other)
382
230
    def __hash__(self):
383
231
        raise ValueError('not hashable')
384
232
 
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
409
233
 
410
234
 
411
235
class RootEntry(InventoryEntry):
412
 
 
413
 
    def _check(self, checker, rev_id, tree):
414
 
        """See InventoryEntry._check"""
415
 
 
416
236
    def __init__(self, file_id):
417
237
        self.file_id = file_id
418
238
        self.children = {}
419
239
        self.kind = 'root_directory'
420
240
        self.parent_id = None
421
 
        self.name = u''
 
241
        self.name = ''
422
242
 
423
243
    def __eq__(self, other):
424
244
        if not isinstance(other, RootEntry):
428
248
               and (self.children == other.children)
429
249
 
430
250
 
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
 
 
486
 
        if self.file_id not in checker.checked_weaves:
487
 
            mutter('check weave {%s}', self.file_id)
488
 
            w = tree.get_weave(self.file_id)
489
 
            # Not passing a progress bar, because it creates a new
490
 
            # progress, which overwrites the current progress,
491
 
            # and doesn't look nice
492
 
            w.check()
493
 
            checker.checked_weaves[self.file_id] = True
494
 
        else:
495
 
            w = tree.get_weave_prelude(self.file_id)
496
 
 
497
 
        mutter('check version {%s} of {%s}', rev_id, self.file_id)
498
 
        checker.checked_text_cnt += 1 
499
 
        # We can't check the length, because Weave doesn't store that
500
 
        # information, and the whole point of looking at the weave's
501
 
        # sha1sum is that we don't have to extract the text.
502
 
        if self.text_sha1 != w.get_sha1(self.revision):
503
 
            raise BzrCheckError('text {%s} version {%s} wrong sha1' 
504
 
                                % (self.file_id, self.revision))
505
 
        checker.checked_texts[t] = self.text_sha1
506
 
 
507
 
    def copy(self):
508
 
        other = InventoryFile(self.file_id, self.name, self.parent_id)
509
 
        other.executable = self.executable
510
 
        other.text_id = self.text_id
511
 
        other.text_sha1 = self.text_sha1
512
 
        other.text_size = self.text_size
513
 
        other.revision = self.revision
514
 
        return other
515
 
 
516
 
    def detect_changes(self, old_entry):
517
 
        """See InventoryEntry.detect_changes."""
518
 
        assert self.text_sha1 != None
519
 
        assert old_entry.text_sha1 != None
520
 
        text_modified = (self.text_sha1 != old_entry.text_sha1)
521
 
        meta_modified = (self.executable != old_entry.executable)
522
 
        return text_modified, meta_modified
523
 
 
524
 
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
525
 
             output_to, reverse=False):
526
 
        """See InventoryEntry._diff."""
527
 
        from_text = tree.get_file(self.file_id).readlines()
528
 
        if to_entry:
529
 
            to_text = to_tree.get_file(to_entry.file_id).readlines()
530
 
        else:
531
 
            to_text = []
532
 
        if not reverse:
533
 
            text_diff(from_label, from_text,
534
 
                      to_label, to_text, output_to)
535
 
        else:
536
 
            text_diff(to_label, to_text,
537
 
                      from_label, from_text, output_to)
538
 
 
539
 
    def has_text(self):
540
 
        """See InventoryEntry.has_text."""
541
 
        return True
542
 
 
543
 
    def __init__(self, file_id, name, parent_id):
544
 
        super(InventoryFile, self).__init__(file_id, name, parent_id)
545
 
        self.kind = 'file'
546
 
 
547
 
    def kind_character(self):
548
 
        """See InventoryEntry.kind_character."""
549
 
        return ''
550
 
 
551
 
    def _put_in_tar(self, item, tree):
552
 
        """See InventoryEntry._put_in_tar."""
553
 
        item.type = tarfile.REGTYPE
554
 
        fileobj = tree.get_file(self.file_id)
555
 
        item.size = self.text_size
556
 
        if tree.is_executable(self.file_id):
557
 
            item.mode = 0755
558
 
        else:
559
 
            item.mode = 0644
560
 
        return fileobj
561
 
 
562
 
    def _put_on_disk(self, fullpath, tree):
563
 
        """See InventoryEntry._put_on_disk."""
564
 
        pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
565
 
        if tree.is_executable(self.file_id):
566
 
            os.chmod(fullpath, 0755)
567
 
 
568
 
    def _read_tree_state(self, path, work_tree):
569
 
        """See InventoryEntry._read_tree_state."""
570
 
        self.text_sha1 = work_tree.get_file_sha1(self.file_id)
571
 
        self.executable = work_tree.is_executable(self.file_id)
572
 
 
573
 
    def _snapshot_text(self, file_parents, work_tree, weave_store, transaction):
574
 
        """See InventoryEntry._snapshot_text."""
575
 
        mutter('storing file {%s} in revision {%s}',
576
 
               self.file_id, self.revision)
577
 
        # special case to avoid diffing on renames or 
578
 
        # reparenting
579
 
        if (len(file_parents) == 1
580
 
            and self.text_sha1 == file_parents.values()[0].text_sha1
581
 
            and self.text_size == file_parents.values()[0].text_size):
582
 
            previous_ie = file_parents.values()[0]
583
 
            weave_store.add_identical_text(
584
 
                self.file_id, previous_ie.revision, 
585
 
                self.revision, file_parents, transaction)
586
 
        else:
587
 
            new_lines = work_tree.get_file(self.file_id).readlines()
588
 
            self._add_text_to_weave(new_lines, file_parents, weave_store,
589
 
                                    transaction)
590
 
            self.text_sha1 = sha_strings(new_lines)
591
 
            self.text_size = sum(map(len, new_lines))
592
 
 
593
 
 
594
 
    def _unchanged(self, previous_ie):
595
 
        """See InventoryEntry._unchanged."""
596
 
        compatible = super(InventoryFile, self)._unchanged(previous_ie)
597
 
        if self.text_sha1 != previous_ie.text_sha1:
598
 
            compatible = False
599
 
        else:
600
 
            # FIXME: 20050930 probe for the text size when getting sha1
601
 
            # in _read_tree_state
602
 
            self.text_size = previous_ie.text_size
603
 
        if self.executable != previous_ie.executable:
604
 
            compatible = False
605
 
        return compatible
606
 
 
607
 
 
608
 
class InventoryLink(InventoryEntry):
609
 
    """A file in an inventory."""
610
 
 
611
 
    __slots__ = ['symlink_target']
612
 
 
613
 
    def _check(self, checker, rev_id, tree):
614
 
        """See InventoryEntry._check"""
615
 
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
616
 
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
617
 
                    % (self.file_id, rev_id))
618
 
        if self.symlink_target == None:
619
 
            raise BzrCheckError('symlink {%s} has no target in revision {%s}'
620
 
                    % (self.file_id, rev_id))
621
 
 
622
 
    def copy(self):
623
 
        other = InventoryLink(self.file_id, self.name, self.parent_id)
624
 
        other.symlink_target = self.symlink_target
625
 
        other.revision = self.revision
626
 
        return other
627
 
 
628
 
    def detect_changes(self, old_entry):
629
 
        """See InventoryEntry.detect_changes."""
630
 
        # FIXME: which _modified field should we use ? RBC 20051003
631
 
        text_modified = (self.symlink_target != old_entry.symlink_target)
632
 
        if text_modified:
633
 
            mutter("    symlink target changed")
634
 
        meta_modified = False
635
 
        return text_modified, meta_modified
636
 
 
637
 
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
638
 
             output_to, reverse=False):
639
 
        """See InventoryEntry._diff."""
640
 
        from_text = self.symlink_target
641
 
        if to_entry is not None:
642
 
            to_text = to_entry.symlink_target
643
 
            if reverse:
644
 
                temp = from_text
645
 
                from_text = to_text
646
 
                to_text = temp
647
 
            print >>output_to, '=== target changed %r => %r' % (from_text, to_text)
648
 
        else:
649
 
            if not reverse:
650
 
                print >>output_to, '=== target was %r' % self.symlink_target
651
 
            else:
652
 
                print >>output_to, '=== target is %r' % self.symlink_target
653
 
 
654
 
    def __init__(self, file_id, name, parent_id):
655
 
        super(InventoryLink, self).__init__(file_id, name, parent_id)
656
 
        self.kind = 'symlink'
657
 
 
658
 
    def kind_character(self):
659
 
        """See InventoryEntry.kind_character."""
660
 
        return ''
661
 
 
662
 
    def _put_in_tar(self, item, tree):
663
 
        """See InventoryEntry._put_in_tar."""
664
 
        item.type = tarfile.SYMTYPE
665
 
        fileobj = None
666
 
        item.size = 0
667
 
        item.mode = 0755
668
 
        item.linkname = self.symlink_target
669
 
        return fileobj
670
 
 
671
 
    def _put_on_disk(self, fullpath, tree):
672
 
        """See InventoryEntry._put_on_disk."""
673
 
        try:
674
 
            os.symlink(self.symlink_target, fullpath)
675
 
        except OSError,e:
676
 
            raise BzrError("Failed to create symlink %r -> %r, error: %s" % (fullpath, self.symlink_target, e))
677
 
 
678
 
    def _read_tree_state(self, path, work_tree):
679
 
        """See InventoryEntry._read_tree_state."""
680
 
        self.symlink_target = work_tree.get_symlink_target(self.file_id)
681
 
 
682
 
    def _unchanged(self, previous_ie):
683
 
        """See InventoryEntry._unchanged."""
684
 
        compatible = super(InventoryLink, self)._unchanged(previous_ie)
685
 
        if self.symlink_target != previous_ie.symlink_target:
686
 
            compatible = False
687
 
        return compatible
688
 
 
689
251
 
690
252
class Inventory(object):
691
253
    """Inventory of versioned files in a tree.
705
267
    inserted, other than through the Inventory API.
706
268
 
707
269
    >>> inv = Inventory()
708
 
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
709
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
 
270
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
710
271
    >>> inv['123-123'].name
711
272
    'hello.c'
712
273
 
722
283
    >>> [x[0] for x in inv.iter_entries()]
723
284
    ['hello.c']
724
285
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
725
 
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
726
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
 
286
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
727
287
    """
728
288
    def __init__(self, root_id=ROOT_ID):
729
289
        """Create or read an inventory.
735
295
        The inventory is created with a default root directory, with
736
296
        an id of None.
737
297
        """
738
 
        # We are letting Branch.create() create a unique inventory
 
298
        # We are letting Branch(init=True) create a unique inventory
739
299
        # root id. Rather than generating a random one here.
740
300
        #if root_id is None:
741
301
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
743
303
        self._byid = {self.root.file_id: self.root}
744
304
 
745
305
 
746
 
    def copy(self):
747
 
        other = Inventory(self.root.file_id)
748
 
        # copy recursively so we know directories will be added before
749
 
        # their children.  There are more efficient ways than this...
750
 
        for path, entry in self.iter_entries():
751
 
            if entry == self.root:
752
 
                continue
753
 
            other.add(entry.copy())
754
 
        return other
755
 
 
756
 
 
757
306
    def __iter__(self):
758
307
        return iter(self._byid)
759
308
 
777
326
            yield name, ie
778
327
            if ie.kind == 'directory':
779
328
                for cn, cie in self.iter_entries(from_dir=ie.file_id):
780
 
                    yield pathjoin(name, cn), cie
 
329
                    yield os.path.join(name, cn), cie
781
330
 
782
331
 
783
332
    def entries(self):
790
339
            kids = dir_ie.children.items()
791
340
            kids.sort()
792
341
            for name, ie in kids:
793
 
                child_path = pathjoin(dir_path, name)
 
342
                child_path = os.path.join(dir_path, name)
794
343
                accum.append((child_path, ie))
795
344
                if ie.kind == 'directory':
796
345
                    descend(ie, child_path)
797
346
 
798
 
        descend(self.root, u'')
 
347
        descend(self.root, '')
799
348
        return accum
800
349
 
801
350
 
810
359
            kids.sort()
811
360
 
812
361
            for name, child_ie in kids:
813
 
                child_path = pathjoin(parent_path, name)
 
362
                child_path = os.path.join(parent_path, name)
814
363
                descend(child_ie, child_path)
815
 
        descend(self.root, u'')
 
364
        descend(self.root, '')
816
365
        return accum
817
366
        
818
367
 
821
370
        """True if this entry contains a file with given id.
822
371
 
823
372
        >>> inv = Inventory()
824
 
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
825
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
 
373
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
826
374
        >>> '123' in inv
827
375
        True
828
376
        >>> '456' in inv
835
383
        """Return the entry for given file_id.
836
384
 
837
385
        >>> inv = Inventory()
838
 
        >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
839
 
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
 
386
        >>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
840
387
        >>> inv['123123'].name
841
388
        'hello.c'
842
389
        """
860
407
        """Add entry to inventory.
861
408
 
862
409
        To add  a file to a branch ready to be committed, use Branch.add,
863
 
        which calls this.
864
 
 
865
 
        Returns the new entry object.
866
 
        """
 
410
        which calls this."""
867
411
        if entry.file_id in self._byid:
868
412
            raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
869
413
 
877
421
 
878
422
        if parent.children.has_key(entry.name):
879
423
            raise BzrError("%s is already versioned" %
880
 
                    pathjoin(self.id2path(parent.file_id), entry.name))
 
424
                    appendpath(self.id2path(parent.file_id), entry.name))
881
425
 
882
426
        self._byid[entry.file_id] = entry
883
427
        parent.children[entry.name] = entry
884
 
        return entry
885
428
 
886
429
 
887
430
    def add_path(self, relpath, kind, file_id=None):
888
431
        """Add entry from a path.
889
432
 
890
 
        The immediate parent must already be versioned.
891
 
 
892
 
        Returns the new entry object."""
893
 
        from bzrlib.workingtree import gen_file_id
 
433
        The immediate parent must already be versioned"""
 
434
        from bzrlib.branch import gen_file_id
894
435
        
895
436
        parts = bzrlib.osutils.splitpath(relpath)
896
437
        if len(parts) == 0:
902
443
        parent_path = parts[:-1]
903
444
        parent_id = self.path2id(parent_path)
904
445
        if parent_id == None:
905
 
            raise NotVersionedError(path=parent_path)
906
 
        if kind == 'directory':
907
 
            ie = InventoryDirectory(file_id, parts[-1], parent_id)
908
 
        elif kind == 'file':
909
 
            ie = InventoryFile(file_id, parts[-1], parent_id)
910
 
        elif kind == 'symlink':
911
 
            ie = InventoryLink(file_id, parts[-1], parent_id)
912
 
        else:
913
 
            raise BzrError("unknown kind %r" % kind)
 
446
            raise NotVersionedError(parent_path)
 
447
 
 
448
        ie = InventoryEntry(file_id, parts[-1],
 
449
                            kind=kind, parent_id=parent_id)
914
450
        return self.add(ie)
915
451
 
916
452
 
918
454
        """Remove entry by id.
919
455
 
920
456
        >>> inv = Inventory()
921
 
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
922
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
 
457
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
923
458
        >>> '123' in inv
924
459
        True
925
460
        >>> del inv['123']
941
476
        del self[ie.parent_id].children[ie.name]
942
477
 
943
478
 
 
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
 
944
516
    def __eq__(self, other):
945
517
        """Compare two sets by comparing their contents.
946
518
 
948
520
        >>> i2 = Inventory()
949
521
        >>> i1 == i2
950
522
        True
951
 
        >>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
952
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
 
523
        >>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
953
524
        >>> i1 == i2
954
525
        False
955
 
        >>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
956
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
 
526
        >>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
957
527
        >>> i1 == i2
958
528
        True
959
529
        """
968
538
 
969
539
 
970
540
    def __ne__(self, other):
971
 
        return not self.__eq__(other)
 
541
        return not (self == other)
972
542
 
973
543
 
974
544
    def __hash__(self):
975
545
        raise ValueError('not hashable')
976
546
 
977
547
 
 
548
 
978
549
    def get_idpath(self, file_id):
979
550
        """Return a list of file_ids for the path to an entry.
980
551
 
995
566
 
996
567
 
997
568
    def id2path(self, file_id):
998
 
        """Return as a list the path to file_id.
999
 
        
1000
 
        >>> i = Inventory()
1001
 
        >>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))
1002
 
        >>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))
1003
 
        >>> print i.id2path('foo-id')
1004
 
        src/foo.c
1005
 
        """
 
569
        """Return as a list the path to file_id."""
 
570
 
1006
571
        # get all names, skipping root
1007
572
        p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
1008
 
        if p:
1009
 
            return pathjoin(*p)
1010
 
        else:
1011
 
            return ''
 
573
        return os.sep.join(p)
1012
574
            
1013
575
 
1014
576