~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Martin Pool
  • Date: 2005-05-02 04:24:33 UTC
  • Revision ID: mbp@sourcefrog.net-20050502042433-c825a7f7235f6b15
doc: notes on merge

Show diffs side-by-side

added added

removed removed

Lines of Context:
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.
 
18
# TODO: Maybe store inventory_id in the file?  Not really needed.
 
19
 
21
20
 
22
21
# This should really be an id randomly assigned when the tree is
23
22
# created, but it's not for now.
24
23
ROOT_ID = "TREE_ROOT"
25
24
 
26
25
 
27
 
import os.path
28
 
import re
29
 
import sys
30
 
import tarfile
31
 
import types
 
26
import sys, os.path, types, re
 
27
from sets import Set
 
28
 
 
29
try:
 
30
    from cElementTree import Element, ElementTree, SubElement
 
31
except ImportError:
 
32
    from elementtree.ElementTree import Element, ElementTree, SubElement
 
33
 
 
34
from xml import XMLMixin
 
35
from errors import bailout, BzrError
32
36
 
33
37
import bzrlib
34
 
from bzrlib.errors import BzrError, BzrCheckError
35
 
 
36
 
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
37
 
                            appendpath, sha_strings)
 
38
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
38
39
from bzrlib.trace import mutter
39
 
from bzrlib.errors import NotVersionedError
40
 
 
41
 
 
42
 
class InventoryEntry(object):
 
40
 
 
41
class InventoryEntry(XMLMixin):
43
42
    """Description of a versioned file.
44
43
 
45
44
    An InventoryEntry has the following fields, which are also
46
45
    present in the XML inventory-entry element:
47
46
 
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.)
 
47
    * *file_id*
 
48
    * *name*: (only the basename within the directory, must not
 
49
      contain slashes)
 
50
    * *kind*: "directory" or "file"
 
51
    * *directory_id*: (if absent/null means the branch root directory)
 
52
    * *text_sha1*: only for files
 
53
    * *text_size*: in bytes, only for files 
 
54
    * *text_id*: identifier for the text version, only for files
 
55
 
 
56
    InventoryEntries can also exist inside a WorkingTree
 
57
    inventory, in which case they are not yet bound to a
 
58
    particular revision of the file.  In that case the text_sha1,
 
59
    text_size and text_id are absent.
 
60
 
71
61
 
72
62
    >>> i = Inventory()
73
63
    >>> i.path2id('')
74
64
    'TREE_ROOT'
75
 
    >>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
76
 
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT')
77
 
    >>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
78
 
    InventoryFile('2323', 'hello.c', parent_id='123')
 
65
    >>> i.add(InventoryEntry('123', 'src', 'directory', ROOT_ID))
 
66
    >>> i.add(InventoryEntry('2323', 'hello.c', 'file', parent_id='123'))
79
67
    >>> for j in i.iter_entries():
80
68
    ...   print j
81
69
    ... 
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'))
 
70
    ('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
 
71
    ('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
 
72
    >>> i.add(InventoryEntry('2323', 'bye.c', 'file', '123'))
85
73
    Traceback (most recent call last):
86
74
    ...
87
 
    BzrError: inventory already contains entry with id {2323}
88
 
    >>> i.add(InventoryFile('2324', 'bye.c', '123'))
89
 
    InventoryFile('2324', 'bye.c', parent_id='123')
90
 
    >>> i.add(InventoryDirectory('2325', 'wibble', '123'))
91
 
    InventoryDirectory('2325', 'wibble', parent_id='123')
 
75
    BzrError: ('inventory already contains entry with id {2323}', [])
 
76
    >>> i.add(InventoryEntry('2324', 'bye.c', 'file', '123'))
 
77
    >>> i.add(InventoryEntry('2325', 'wibble', 'directory', '123'))
92
78
    >>> i.path2id('src/wibble')
93
79
    '2325'
94
80
    >>> '2325' in i
95
81
    True
96
 
    >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
97
 
    InventoryFile('2326', 'wibble.c', parent_id='2325')
 
82
    >>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
98
83
    >>> i['2326']
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)
 
84
    InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
 
85
    >>> for j in i.iter_entries():
 
86
    ...     print j[0]
 
87
    ...     assert i.path2id(j[0])
103
88
    ... 
104
89
    src
105
90
    src/bye.c
106
91
    src/hello.c
107
92
    src/wibble
108
93
    src/wibble/wibble.c
109
 
    >>> i.id2path('2326').replace('\\\\', '/')
 
94
    >>> i.id2path('2326')
110
95
    'src/wibble/wibble.c'
 
96
 
 
97
    TODO: Maybe also keep the full path of the entry, and the children?
 
98
           But those depend on its position within a particular inventory, and
 
99
           it would be nice not to need to hold the backpointer here.
111
100
    """
 
101
 
 
102
    # TODO: split InventoryEntry into subclasses for files,
 
103
    # directories, etc etc.
112
104
    
113
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
114
 
                 'text_id', 'parent_id', 'children', 'executable', 
115
 
                 'revision']
116
 
 
117
 
    def _add_text_to_weave(self, new_lines, parents, weave_store, transaction):
118
 
        weave_store.add_text(self.file_id, self.revision, new_lines, parents,
119
 
                             transaction)
120
 
 
121
 
    def detect_changes(self, old_entry):
122
 
        """Return a (text_modified, meta_modified) from this to old_entry.
123
 
        
124
 
        _read_tree_state must have been called on self and old_entry prior to 
125
 
        calling detect_changes.
126
 
        """
127
 
        return False, False
128
 
 
129
 
    def diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
130
 
             output_to, reverse=False):
131
 
        """Perform a diff from this to to_entry.
132
 
 
133
 
        text_diff will be used for textual difference calculation.
134
 
        This is a template method, override _diff in child classes.
135
 
        """
136
 
        self._read_tree_state(tree.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):
 
105
    def __init__(self, file_id, name, kind, parent_id, text_id=None):
220
106
        """Create an InventoryEntry
221
107
        
222
108
        The filename must be a single component, relative to the
223
109
        parent directory; it cannot be a whole path or relative name.
224
110
 
225
 
        >>> e = InventoryFile('123', 'hello.c', ROOT_ID)
 
111
        >>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
226
112
        >>> e.name
227
113
        'hello.c'
228
114
        >>> e.file_id
229
115
        '123'
230
 
        >>> e = InventoryFile('123', 'src/hello.c', ROOT_ID)
 
116
        >>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
231
117
        Traceback (most recent call last):
232
 
        BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
 
118
        BzrError: ("InventoryEntry name is not a simple filename: 'src/hello.c'", [])
233
119
        """
234
 
        assert isinstance(name, basestring), name
235
 
        if '/' in name or '\\' in name:
236
 
            raise BzrCheckError('InventoryEntry name %r is invalid' % name)
237
 
        
238
 
        self.executable = False
239
 
        self.revision = None
240
 
        self.text_sha1 = None
241
 
        self.text_size = None
 
120
        
 
121
        if len(splitpath(name)) != 1:
 
122
            bailout('InventoryEntry name is not a simple filename: %r'
 
123
                    % name)
 
124
        
242
125
        self.file_id = file_id
243
126
        self.name = name
 
127
        self.kind = kind
244
128
        self.text_id = text_id
245
129
        self.parent_id = parent_id
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))
 
130
        self.text_sha1 = None
 
131
        self.text_size = None
 
132
        if kind == 'directory':
 
133
            self.children = {}
 
134
        elif kind == 'file':
 
135
            pass
 
136
        else:
 
137
            raise BzrError("unhandled entry kind %r" % kind)
 
138
 
 
139
 
274
140
 
275
141
    def sorted_children(self):
276
142
        l = self.children.items()
277
143
        l.sort()
278
144
        return l
279
145
 
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
 
 
301
146
 
302
147
    def copy(self):
303
 
        """Clone this inventory entry."""
304
 
        raise NotImplementedError
 
148
        other = InventoryEntry(self.file_id, self.name, self.kind,
 
149
                               self.parent_id, text_id=self.text_id)
 
150
        other.text_sha1 = self.text_sha1
 
151
        other.text_size = self.text_size
 
152
        return other
305
153
 
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'
313
154
 
314
155
    def __repr__(self):
315
 
        return ("%s(%r, %r, parent_id=%r)"
 
156
        return ("%s(%r, %r, kind=%r, parent_id=%r)"
316
157
                % (self.__class__.__name__,
317
158
                   self.file_id,
318
159
                   self.name,
 
160
                   self.kind,
319
161
                   self.parent_id))
320
162
 
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)
358
 
 
359
 
    def __eq__(self, other):
 
163
    
 
164
    def to_element(self):
 
165
        """Convert to XML element"""
 
166
        e = Element('entry')
 
167
 
 
168
        e.set('name', self.name)
 
169
        e.set('file_id', self.file_id)
 
170
        e.set('kind', self.kind)
 
171
 
 
172
        if self.text_size != None:
 
173
            e.set('text_size', '%d' % self.text_size)
 
174
            
 
175
        for f in ['text_id', 'text_sha1']:
 
176
            v = getattr(self, f)
 
177
            if v != None:
 
178
                e.set(f, v)
 
179
 
 
180
        # to be conservative, we don't externalize the root pointers
 
181
        # for now, leaving them as null in the xml form.  in a future
 
182
        # version it will be implied by nested elements.
 
183
        if self.parent_id != ROOT_ID:
 
184
            assert isinstance(self.parent_id, basestring)
 
185
            e.set('parent_id', self.parent_id)
 
186
 
 
187
        e.tail = '\n'
 
188
            
 
189
        return e
 
190
 
 
191
 
 
192
    def from_element(cls, elt):
 
193
        assert elt.tag == 'entry'
 
194
 
 
195
        ## original format inventories don't have a parent_id for
 
196
        ## nodes in the root directory, but it's cleaner to use one
 
197
        ## internally.
 
198
        parent_id = elt.get('parent_id')
 
199
        if parent_id == None:
 
200
            parent_id = ROOT_ID
 
201
 
 
202
        self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'), parent_id)
 
203
        self.text_id = elt.get('text_id')
 
204
        self.text_sha1 = elt.get('text_sha1')
 
205
        
 
206
        ## mutter("read inventoryentry: %r" % (elt.attrib))
 
207
 
 
208
        v = elt.get('text_size')
 
209
        self.text_size = v and int(v)
 
210
 
 
211
        return self
 
212
            
 
213
 
 
214
    from_element = classmethod(from_element)
 
215
 
 
216
    def __cmp__(self, other):
 
217
        if self is other:
 
218
            return 0
360
219
        if not isinstance(other, InventoryEntry):
361
220
            return NotImplemented
362
221
 
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
 
                )
374
 
 
375
 
    def __ne__(self, other):
376
 
        return not (self == other)
377
 
 
378
 
    def __hash__(self):
379
 
        raise ValueError('not hashable')
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
 
        """
 
222
        return cmp(self.file_id, other.file_id) \
 
223
               or cmp(self.name, other.name) \
 
224
               or cmp(self.text_sha1, other.text_sha1) \
 
225
               or cmp(self.text_size, other.text_size) \
 
226
               or cmp(self.text_id, other.text_id) \
 
227
               or cmp(self.parent_id, other.parent_id) \
 
228
               or cmp(self.kind, other.kind)
 
229
 
401
230
 
402
231
 
403
232
class RootEntry(InventoryEntry):
404
 
 
405
 
    def _check(self, checker, rev_id, tree):
406
 
        """See InventoryEntry._check"""
407
 
 
408
233
    def __init__(self, file_id):
409
234
        self.file_id = file_id
410
235
        self.children = {}
412
237
        self.parent_id = None
413
238
        self.name = ''
414
239
 
415
 
    def __eq__(self, other):
 
240
    def __cmp__(self, other):
 
241
        if self is other:
 
242
            return 0
416
243
        if not isinstance(other, RootEntry):
417
244
            return NotImplemented
418
 
        
419
 
        return (self.file_id == other.file_id) \
420
 
               and (self.children == other.children)
421
 
 
422
 
 
423
 
class InventoryDirectory(InventoryEntry):
424
 
    """A directory in an inventory."""
425
 
 
426
 
    def _check(self, checker, rev_id, tree):
427
 
        """See InventoryEntry._check"""
428
 
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
429
 
            raise BzrCheckError('directory {%s} has text in revision {%s}'
430
 
                                % (self.file_id, rev_id))
431
 
 
432
 
    def copy(self):
433
 
        other = InventoryDirectory(self.file_id, self.name, self.parent_id)
434
 
        other.revision = self.revision
435
 
        # note that children are *not* copied; they're pulled across when
436
 
        # others are added
437
 
        return other
438
 
 
439
 
    def __init__(self, file_id, name, parent_id):
440
 
        super(InventoryDirectory, self).__init__(file_id, name, parent_id)
441
 
        self.children = {}
442
 
        self.kind = 'directory'
443
 
 
444
 
    def kind_character(self):
445
 
        """See InventoryEntry.kind_character."""
446
 
        return '/'
447
 
 
448
 
    def _put_in_tar(self, item, tree):
449
 
        """See InventoryEntry._put_in_tar."""
450
 
        item.type = tarfile.DIRTYPE
451
 
        fileobj = None
452
 
        item.name += '/'
453
 
        item.size = 0
454
 
        item.mode = 0755
455
 
        return fileobj
456
 
 
457
 
    def _put_on_disk(self, fullpath, tree):
458
 
        """See InventoryEntry._put_on_disk."""
459
 
        os.mkdir(fullpath)
460
 
 
461
 
 
462
 
class InventoryFile(InventoryEntry):
463
 
    """A file in an inventory."""
464
 
 
465
 
    def _check(self, checker, rev_id, tree):
466
 
        """See InventoryEntry._check"""
467
 
        revision = self.revision
468
 
        t = (self.file_id, revision)
469
 
        if t in checker.checked_texts:
470
 
            prev_sha = checker.checked_texts[t] 
471
 
            if prev_sha != self.text_sha1:
472
 
                raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
473
 
                                    (self.file_id, rev_id))
474
 
            else:
475
 
                checker.repeated_text_cnt += 1
476
 
                return
477
 
        mutter('check version {%s} of {%s}', rev_id, self.file_id)
478
 
        file_lines = tree.get_file_lines(self.file_id)
479
 
        checker.checked_text_cnt += 1 
480
 
        if self.text_size != sum(map(len, file_lines)):
481
 
            raise BzrCheckError('text {%s} wrong size' % self.text_id)
482
 
        if self.text_sha1 != sha_strings(file_lines):
483
 
            raise BzrCheckError('text {%s} wrong sha1' % self.text_id)
484
 
        checker.checked_texts[t] = self.text_sha1
485
 
 
486
 
    def copy(self):
487
 
        other = InventoryFile(self.file_id, self.name, self.parent_id)
488
 
        other.executable = self.executable
489
 
        other.text_id = self.text_id
490
 
        other.text_sha1 = self.text_sha1
491
 
        other.text_size = self.text_size
492
 
        other.revision = self.revision
493
 
        return other
494
 
 
495
 
    def detect_changes(self, old_entry):
496
 
        """See InventoryEntry.detect_changes."""
497
 
        assert self.text_sha1 != None
498
 
        assert old_entry.text_sha1 != None
499
 
        text_modified = (self.text_sha1 != old_entry.text_sha1)
500
 
        meta_modified = (self.executable != old_entry.executable)
501
 
        return text_modified, meta_modified
502
 
 
503
 
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
504
 
             output_to, reverse=False):
505
 
        """See InventoryEntry._diff."""
506
 
        from_text = tree.get_file(self.file_id).readlines()
507
 
        if to_entry:
508
 
            to_text = to_tree.get_file(to_entry.file_id).readlines()
509
 
        else:
510
 
            to_text = []
511
 
        if not reverse:
512
 
            text_diff(from_label, from_text,
513
 
                      to_label, to_text, output_to)
514
 
        else:
515
 
            text_diff(to_label, to_text,
516
 
                      from_label, from_text, output_to)
517
 
 
518
 
    def has_text(self):
519
 
        """See InventoryEntry.has_text."""
520
 
        return True
521
 
 
522
 
    def __init__(self, file_id, name, parent_id):
523
 
        super(InventoryFile, self).__init__(file_id, name, parent_id)
524
 
        self.kind = 'file'
525
 
 
526
 
    def kind_character(self):
527
 
        """See InventoryEntry.kind_character."""
528
 
        return ''
529
 
 
530
 
    def _put_in_tar(self, item, tree):
531
 
        """See InventoryEntry._put_in_tar."""
532
 
        item.type = tarfile.REGTYPE
533
 
        fileobj = tree.get_file(self.file_id)
534
 
        item.size = self.text_size
535
 
        if tree.is_executable(self.file_id):
536
 
            item.mode = 0755
537
 
        else:
538
 
            item.mode = 0644
539
 
        return fileobj
540
 
 
541
 
    def _put_on_disk(self, fullpath, tree):
542
 
        """See InventoryEntry._put_on_disk."""
543
 
        pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
544
 
        if tree.is_executable(self.file_id):
545
 
            os.chmod(fullpath, 0755)
546
 
 
547
 
    def _read_tree_state(self, path, work_tree):
548
 
        """See InventoryEntry._read_tree_state."""
549
 
        self.text_sha1 = work_tree.get_file_sha1(self.file_id)
550
 
        self.executable = work_tree.is_executable(self.file_id)
551
 
 
552
 
    def _snapshot_text(self, file_parents, work_tree, weave_store, transaction):
553
 
        """See InventoryEntry._snapshot_text."""
554
 
        mutter('storing file {%s} in revision {%s}',
555
 
               self.file_id, self.revision)
556
 
        # special case to avoid diffing on renames or 
557
 
        # reparenting
558
 
        if (len(file_parents) == 1
559
 
            and self.text_sha1 == file_parents.values()[0].text_sha1
560
 
            and self.text_size == file_parents.values()[0].text_size):
561
 
            previous_ie = file_parents.values()[0]
562
 
            weave_store.add_identical_text(
563
 
                self.file_id, previous_ie.revision, 
564
 
                self.revision, file_parents, transaction)
565
 
        else:
566
 
            new_lines = work_tree.get_file(self.file_id).readlines()
567
 
            self._add_text_to_weave(new_lines, file_parents, weave_store,
568
 
                                    transaction)
569
 
            self.text_sha1 = sha_strings(new_lines)
570
 
            self.text_size = sum(map(len, new_lines))
571
 
 
572
 
 
573
 
    def _unchanged(self, previous_ie):
574
 
        """See InventoryEntry._unchanged."""
575
 
        compatible = super(InventoryFile, self)._unchanged(previous_ie)
576
 
        if self.text_sha1 != previous_ie.text_sha1:
577
 
            compatible = False
578
 
        else:
579
 
            # FIXME: 20050930 probe for the text size when getting sha1
580
 
            # in _read_tree_state
581
 
            self.text_size = previous_ie.text_size
582
 
        if self.executable != previous_ie.executable:
583
 
            compatible = False
584
 
        return compatible
585
 
 
586
 
 
587
 
class InventoryLink(InventoryEntry):
588
 
    """A file in an inventory."""
589
 
 
590
 
    __slots__ = ['symlink_target']
591
 
 
592
 
    def _check(self, checker, rev_id, tree):
593
 
        """See InventoryEntry._check"""
594
 
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
595
 
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
596
 
                    % (self.file_id, rev_id))
597
 
        if self.symlink_target == None:
598
 
            raise BzrCheckError('symlink {%s} has no target in revision {%s}'
599
 
                    % (self.file_id, rev_id))
600
 
 
601
 
    def copy(self):
602
 
        other = InventoryLink(self.file_id, self.name, self.parent_id)
603
 
        other.symlink_target = self.symlink_target
604
 
        other.revision = self.revision
605
 
        return other
606
 
 
607
 
    def detect_changes(self, old_entry):
608
 
        """See InventoryEntry.detect_changes."""
609
 
        # FIXME: which _modified field should we use ? RBC 20051003
610
 
        text_modified = (self.symlink_target != old_entry.symlink_target)
611
 
        if text_modified:
612
 
            mutter("    symlink target changed")
613
 
        meta_modified = False
614
 
        return text_modified, meta_modified
615
 
 
616
 
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
617
 
             output_to, reverse=False):
618
 
        """See InventoryEntry._diff."""
619
 
        from_text = self.symlink_target
620
 
        if to_entry is not None:
621
 
            to_text = to_entry.symlink_target
622
 
            if reverse:
623
 
                temp = from_text
624
 
                from_text = to_text
625
 
                to_text = temp
626
 
            print >>output_to, '=== target changed %r => %r' % (from_text, to_text)
627
 
        else:
628
 
            if not reverse:
629
 
                print >>output_to, '=== target was %r' % self.symlink_target
630
 
            else:
631
 
                print >>output_to, '=== target is %r' % self.symlink_target
632
 
 
633
 
    def __init__(self, file_id, name, parent_id):
634
 
        super(InventoryLink, self).__init__(file_id, name, parent_id)
635
 
        self.kind = 'symlink'
636
 
 
637
 
    def kind_character(self):
638
 
        """See InventoryEntry.kind_character."""
639
 
        return ''
640
 
 
641
 
    def _put_in_tar(self, item, tree):
642
 
        """See InventoryEntry._put_in_tar."""
643
 
        iterm.type = tarfile.SYMTYPE
644
 
        fileobj = None
645
 
        item.size = 0
646
 
        item.mode = 0755
647
 
        item.linkname = self.symlink_target
648
 
        return fileobj
649
 
 
650
 
    def _put_on_disk(self, fullpath, tree):
651
 
        """See InventoryEntry._put_on_disk."""
652
 
        try:
653
 
            os.symlink(self.symlink_target, fullpath)
654
 
        except OSError,e:
655
 
            raise BzrError("Failed to create symlink %r -> %r, error: %s" % (fullpath, self.symlink_target, e))
656
 
 
657
 
    def _read_tree_state(self, path, work_tree):
658
 
        """See InventoryEntry._read_tree_state."""
659
 
        self.symlink_target = work_tree.get_symlink_target(self.file_id)
660
 
 
661
 
    def _unchanged(self, previous_ie):
662
 
        """See InventoryEntry._unchanged."""
663
 
        compatible = super(InventoryLink, self)._unchanged(previous_ie)
664
 
        if self.symlink_target != previous_ie.symlink_target:
665
 
            compatible = False
666
 
        return compatible
667
 
 
668
 
 
669
 
class Inventory(object):
 
245
        return cmp(self.file_id, other.file_id) \
 
246
               or cmp(self.children, other.children)
 
247
 
 
248
 
 
249
 
 
250
class Inventory(XMLMixin):
670
251
    """Inventory of versioned files in a tree.
671
252
 
672
253
    This describes which file_id is present at each point in the tree,
684
265
    inserted, other than through the Inventory API.
685
266
 
686
267
    >>> inv = Inventory()
687
 
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
688
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
 
268
    >>> inv.write_xml(sys.stdout)
 
269
    <inventory>
 
270
    </inventory>
 
271
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
689
272
    >>> inv['123-123'].name
690
273
    'hello.c'
691
274
 
700
283
 
701
284
    >>> [x[0] for x in inv.iter_entries()]
702
285
    ['hello.c']
703
 
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
704
 
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
705
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
 
286
    
 
287
    >>> inv.write_xml(sys.stdout)
 
288
    <inventory>
 
289
    <entry file_id="123-123" kind="file" name="hello.c" />
 
290
    </inventory>
 
291
 
706
292
    """
707
 
    def __init__(self, root_id=ROOT_ID):
 
293
 
 
294
    ## TODO: Make sure only canonical filenames are stored.
 
295
 
 
296
    ## TODO: Do something sensible about the possible collisions on
 
297
    ## case-losing filesystems.  Perhaps we should just always forbid
 
298
    ## such collisions.
 
299
 
 
300
    ## TODO: No special cases for root, rather just give it a file id
 
301
    ## like everything else.
 
302
 
 
303
    ## TODO: Probably change XML serialization to use nesting rather
 
304
    ## than parent_id pointers.
 
305
 
 
306
    ## TODO: Perhaps hold the ElementTree in memory and work directly
 
307
    ## on that rather than converting into Python objects every time?
 
308
 
 
309
    def __init__(self):
708
310
        """Create or read an inventory.
709
311
 
710
312
        If a working directory is specified, the inventory is read
714
316
        The inventory is created with a default root directory, with
715
317
        an id of None.
716
318
        """
717
 
        # We are letting Branch.initialize() create a unique inventory
718
 
        # root id. Rather than generating a random one here.
719
 
        #if root_id is None:
720
 
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
721
 
        self.root = RootEntry(root_id)
 
319
        self.root = RootEntry(ROOT_ID)
722
320
        self._byid = {self.root.file_id: self.root}
723
321
 
724
322
 
725
 
    def copy(self):
726
 
        other = Inventory(self.root.file_id)
727
 
        # copy recursively so we know directories will be added before
728
 
        # their children.  There are more efficient ways than this...
729
 
        for path, entry in self.iter_entries():
730
 
            if entry == self.root:
731
 
                continue
732
 
            other.add(entry.copy())
733
 
        return other
734
 
 
735
 
 
736
323
    def __iter__(self):
737
324
        return iter(self._byid)
738
325
 
757
344
            if ie.kind == 'directory':
758
345
                for cn, cie in self.iter_entries(from_dir=ie.file_id):
759
346
                    yield os.path.join(name, cn), cie
760
 
 
761
 
 
762
 
    def entries(self):
763
 
        """Return list of (path, ie) for all entries except the root.
764
 
 
765
 
        This may be faster than iter_entries.
 
347
                    
 
348
 
 
349
 
 
350
    def directories(self):
 
351
        """Return (path, entry) pairs for all directories.
766
352
        """
767
 
        accum = []
768
 
        def descend(dir_ie, dir_path):
769
 
            kids = dir_ie.children.items()
770
 
            kids.sort()
771
 
            for name, ie in kids:
772
 
                child_path = os.path.join(dir_path, name)
773
 
                accum.append((child_path, ie))
 
353
        def descend(parent_ie):
 
354
            parent_name = parent_ie.name
 
355
            yield parent_name, parent_ie
 
356
 
 
357
            # directory children in sorted order
 
358
            dn = []
 
359
            for ie in parent_ie.children.itervalues():
774
360
                if ie.kind == 'directory':
775
 
                    descend(ie, child_path)
776
 
 
777
 
        descend(self.root, '')
778
 
        return accum
779
 
 
780
 
 
781
 
    def directories(self):
782
 
        """Return (path, entry) pairs for all directories, including the root.
783
 
        """
784
 
        accum = []
785
 
        def descend(parent_ie, parent_path):
786
 
            accum.append((parent_path, parent_ie))
 
361
                    dn.append((ie.name, ie))
 
362
            dn.sort()
787
363
            
788
 
            kids = [(ie.name, ie) for ie in parent_ie.children.itervalues() if ie.kind == 'directory']
789
 
            kids.sort()
 
364
            for name, child_ie in dn:
 
365
                for sub_name, sub_ie in descend(child_ie):
 
366
                    yield appendpath(parent_name, sub_name), sub_ie
790
367
 
791
 
            for name, child_ie in kids:
792
 
                child_path = os.path.join(parent_path, name)
793
 
                descend(child_ie, child_path)
794
 
        descend(self.root, '')
795
 
        return accum
 
368
        for name, ie in descend(self.root):
 
369
            yield name, ie
796
370
        
797
371
 
798
372
 
800
374
        """True if this entry contains a file with given id.
801
375
 
802
376
        >>> inv = Inventory()
803
 
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
804
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
 
377
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
805
378
        >>> '123' in inv
806
379
        True
807
380
        >>> '456' in inv
814
387
        """Return the entry for given file_id.
815
388
 
816
389
        >>> inv = Inventory()
817
 
        >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
818
 
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
 
390
        >>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
819
391
        >>> inv['123123'].name
820
392
        'hello.c'
821
393
        """
 
394
        if file_id == None:
 
395
            raise BzrError("can't look up file_id None")
 
396
            
822
397
        try:
823
398
            return self._byid[file_id]
824
399
        except KeyError:
825
 
            if file_id == None:
826
 
                raise BzrError("can't look up file_id None")
827
 
            else:
828
 
                raise BzrError("file_id {%s} not in inventory" % file_id)
829
 
 
830
 
 
831
 
    def get_file_kind(self, file_id):
832
 
        return self._byid[file_id].kind
 
400
            raise BzrError("file_id {%s} not in inventory" % file_id)
 
401
 
833
402
 
834
403
    def get_child(self, parent_id, filename):
835
404
        return self[parent_id].children.get(filename)
839
408
        """Add entry to inventory.
840
409
 
841
410
        To add  a file to a branch ready to be committed, use Branch.add,
842
 
        which calls this.
843
 
 
844
 
        Returns the new entry object.
845
 
        """
 
411
        which calls this."""
846
412
        if entry.file_id in self._byid:
847
 
            raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
848
 
 
849
 
        if entry.parent_id == ROOT_ID or entry.parent_id is None:
850
 
            entry.parent_id = self.root.file_id
 
413
            bailout("inventory already contains entry with id {%s}" % entry.file_id)
851
414
 
852
415
        try:
853
416
            parent = self._byid[entry.parent_id]
854
417
        except KeyError:
855
 
            raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
 
418
            bailout("parent_id {%s} not in inventory" % entry.parent_id)
856
419
 
857
420
        if parent.children.has_key(entry.name):
858
 
            raise BzrError("%s is already versioned" %
 
421
            bailout("%s is already versioned" %
859
422
                    appendpath(self.id2path(parent.file_id), entry.name))
860
423
 
861
424
        self._byid[entry.file_id] = entry
862
425
        parent.children[entry.name] = entry
863
 
        return entry
864
426
 
865
427
 
866
428
    def add_path(self, relpath, kind, file_id=None):
867
429
        """Add entry from a path.
868
430
 
869
 
        The immediate parent must already be versioned.
870
 
 
871
 
        Returns the new entry object."""
872
 
        from bzrlib.branch import gen_file_id
873
 
        
 
431
        The immediate parent must already be versioned"""
874
432
        parts = bzrlib.osutils.splitpath(relpath)
875
433
        if len(parts) == 0:
876
 
            raise BzrError("cannot re-add root of inventory")
 
434
            bailout("cannot re-add root of inventory")
877
435
 
878
436
        if file_id == None:
879
 
            file_id = gen_file_id(relpath)
880
 
 
881
 
        parent_path = parts[:-1]
882
 
        parent_id = self.path2id(parent_path)
883
 
        if parent_id == None:
884
 
            raise NotVersionedError(parent_path)
885
 
 
886
 
        if kind == 'directory':
887
 
            ie = InventoryDirectory(file_id, parts[-1], parent_id)
888
 
        elif kind == 'file':
889
 
            ie = InventoryFile(file_id, parts[-1], parent_id)
890
 
        elif kind == 'symlink':
891
 
            ie = InventoryLink(file_id, parts[-1], parent_id)
892
 
        else:
893
 
            raise BzrError("unknown kind %r" % kind)
 
437
            file_id = bzrlib.branch.gen_file_id(relpath)
 
438
 
 
439
        parent_id = self.path2id(parts[:-1])
 
440
        assert parent_id != None
 
441
        ie = InventoryEntry(file_id, parts[-1],
 
442
                            kind=kind, parent_id=parent_id)
894
443
        return self.add(ie)
895
444
 
896
445
 
898
447
        """Remove entry by id.
899
448
 
900
449
        >>> inv = Inventory()
901
 
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
902
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
 
450
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
903
451
        >>> '123' in inv
904
452
        True
905
453
        >>> del inv['123']
921
469
        del self[ie.parent_id].children[ie.name]
922
470
 
923
471
 
924
 
    def __eq__(self, other):
 
472
    def id_set(self):
 
473
        return Set(self._byid)
 
474
 
 
475
 
 
476
    def to_element(self):
 
477
        """Convert to XML Element"""
 
478
        e = Element('inventory')
 
479
        e.text = '\n'
 
480
        for path, ie in self.iter_entries():
 
481
            e.append(ie.to_element())
 
482
        return e
 
483
    
 
484
 
 
485
    def from_element(cls, elt):
 
486
        """Construct from XML Element
 
487
 
 
488
        >>> inv = Inventory()
 
489
        >>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c', 'file', ROOT_ID))
 
490
        >>> elt = inv.to_element()
 
491
        >>> inv2 = Inventory.from_element(elt)
 
492
        >>> inv2 == inv
 
493
        True
 
494
        """
 
495
        assert elt.tag == 'inventory'
 
496
        o = cls()
 
497
        for e in elt:
 
498
            o.add(InventoryEntry.from_element(e))
 
499
        return o
 
500
        
 
501
    from_element = classmethod(from_element)
 
502
 
 
503
 
 
504
    def __cmp__(self, other):
925
505
        """Compare two sets by comparing their contents.
926
506
 
927
507
        >>> i1 = Inventory()
928
508
        >>> i2 = Inventory()
929
509
        >>> i1 == i2
930
510
        True
931
 
        >>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
932
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
 
511
        >>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
933
512
        >>> i1 == i2
934
513
        False
935
 
        >>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
936
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
 
514
        >>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
937
515
        >>> i1 == i2
938
516
        True
939
517
        """
 
518
        if self is other:
 
519
            return 0
 
520
        
940
521
        if not isinstance(other, Inventory):
941
522
            return NotImplemented
942
523
 
943
 
        if len(self._byid) != len(other._byid):
944
 
            # shortcut: obviously not the same
945
 
            return False
946
 
 
947
 
        return self._byid == other._byid
948
 
 
949
 
 
950
 
    def __ne__(self, other):
951
 
        return not self.__eq__(other)
952
 
 
953
 
 
954
 
    def __hash__(self):
955
 
        raise ValueError('not hashable')
 
524
        if self.id_set() ^ other.id_set():
 
525
            return 1
 
526
 
 
527
        for file_id in self._byid:
 
528
            c = cmp(self[file_id], other[file_id])
 
529
            if c: return c
 
530
 
 
531
        return 0
956
532
 
957
533
 
958
534
    def get_idpath(self, file_id):
968
544
            try:
969
545
                ie = self._byid[file_id]
970
546
            except KeyError:
971
 
                raise BzrError("file_id {%s} not found in inventory" % file_id)
 
547
                bailout("file_id {%s} not found in inventory" % file_id)
972
548
            p.insert(0, ie.file_id)
973
549
            file_id = ie.parent_id
974
550
        return p
975
551
 
976
552
 
977
553
    def id2path(self, file_id):
978
 
        """Return as a list the path to file_id.
979
 
        
980
 
        >>> i = Inventory()
981
 
        >>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))
982
 
        >>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))
983
 
        >>> print i.id2path('foo-id').replace(os.sep, '/')
984
 
        src/foo.c
985
 
        """
 
554
        """Return as a list the path to file_id."""
 
555
 
986
556
        # get all names, skipping root
987
 
        p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
 
557
        p = [self[fid].name for fid in self.get_idpath(file_id)[1:]]
988
558
        return os.sep.join(p)
989
559
            
990
560
 
1034
604
 
1035
605
        This does not move the working file."""
1036
606
        if not is_valid_name(new_name):
1037
 
            raise BzrError("not an acceptable filename: %r" % new_name)
 
607
            bailout("not an acceptable filename: %r" % new_name)
1038
608
 
1039
609
        new_parent = self._byid[new_parent_id]
1040
610
        if new_name in new_parent.children:
1041
 
            raise BzrError("%r already exists in %r" % (new_name, self.id2path(new_parent_id)))
 
611
            bailout("%r already exists in %r" % (new_name, self.id2path(new_parent_id)))
1042
612
 
1043
613
        new_parent_idpath = self.get_idpath(new_parent_id)
1044
614
        if file_id in new_parent_idpath:
1045
 
            raise BzrError("cannot move directory %r into a subdirectory of itself, %r"
 
615
            bailout("cannot move directory %r into a subdirectory of itself, %r"
1046
616
                    % (self.id2path(file_id), self.id2path(new_parent_id)))
1047
617
 
1048
618
        file_ie = self._byid[file_id]
1059
629
 
1060
630
 
1061
631
 
1062
 
_NAME_RE = None
 
632
_NAME_RE = re.compile(r'^[^/\\]+$')
1063
633
 
1064
634
def is_valid_name(name):
1065
 
    global _NAME_RE
1066
 
    if _NAME_RE == None:
1067
 
        _NAME_RE = re.compile(r'^[^/\\]+$')
1068
 
        
1069
635
    return bool(_NAME_RE.match(name))