~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Aaron Bentley
  • Date: 2009-03-24 12:15:01 UTC
  • mfrom: (4195 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4196.
  • Revision ID: aaron@aaronbentley.com-20090324121501-rd8zjsdk9fok8mvk
Merge and resolve NEWS conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""MutableTree object.
 
18
 
 
19
See MutableTree for more details.
 
20
"""
 
21
 
 
22
 
 
23
from bzrlib.lazy_import import lazy_import
 
24
lazy_import(globals(), """
 
25
import os
 
26
 
 
27
from bzrlib import (
 
28
    add,
 
29
    bzrdir,
 
30
    hooks,
 
31
    symbol_versioning,
 
32
    )
 
33
from bzrlib.osutils import dirname
 
34
from bzrlib.revisiontree import RevisionTree
 
35
from bzrlib.trace import mutter, warning
 
36
""")
 
37
 
 
38
from bzrlib import (
 
39
    errors,
 
40
    osutils,
 
41
    tree,
 
42
    )
 
43
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
44
from bzrlib.osutils import splitpath
 
45
 
 
46
 
 
47
def needs_tree_write_lock(unbound):
 
48
    """Decorate unbound to take out and release a tree_write lock."""
 
49
    def tree_write_locked(self, *args, **kwargs):
 
50
        self.lock_tree_write()
 
51
        try:
 
52
            return unbound(self, *args, **kwargs)
 
53
        finally:
 
54
            self.unlock()
 
55
    tree_write_locked.__doc__ = unbound.__doc__
 
56
    tree_write_locked.__name__ = unbound.__name__
 
57
    return tree_write_locked
 
58
 
 
59
 
 
60
class MutableTree(tree.Tree):
 
61
    """A MutableTree is a specialisation of Tree which is able to be mutated.
 
62
 
 
63
    Generally speaking these mutations are only possible within a lock_write
 
64
    context, and will revert if the lock is broken abnormally - but this cannot
 
65
    be guaranteed - depending on the exact implementation of the mutable state.
 
66
 
 
67
    The most common form of Mutable Tree is WorkingTree, see bzrlib.workingtree.
 
68
    For tests we also have MemoryTree which is a MutableTree whose contents are
 
69
    entirely in memory.
 
70
 
 
71
    For now, we are not treating MutableTree as an interface to provide
 
72
    conformance tests for - rather we are testing MemoryTree specifically, and
 
73
    interface testing implementations of WorkingTree.
 
74
 
 
75
    A mutable tree always has an associated Branch and BzrDir object - the
 
76
    branch and bzrdir attributes.
 
77
    """
 
78
    def __init__(self, *args, **kw):
 
79
        super(MutableTree, self).__init__(*args, **kw)
 
80
        # Is this tree on a case-insensitive or case-preserving file-system?
 
81
        # Sub-classes may initialize to False if they detect they are being
 
82
        # used on media which doesn't differentiate the case of names.
 
83
        self.case_sensitive = True
 
84
 
 
85
    @needs_tree_write_lock
 
86
    def add(self, files, ids=None, kinds=None):
 
87
        """Add paths to the set of versioned paths.
 
88
 
 
89
        Note that the command line normally calls smart_add instead,
 
90
        which can automatically recurse.
 
91
 
 
92
        This adds the files to the inventory, so that they will be
 
93
        recorded by the next commit.
 
94
 
 
95
        :param files: List of paths to add, relative to the base of the tree.
 
96
        :param ids: If set, use these instead of automatically generated ids.
 
97
            Must be the same length as the list of files, but may
 
98
            contain None for ids that are to be autogenerated.
 
99
        :param kinds: Optional parameter to specify the kinds to be used for
 
100
            each file.
 
101
 
 
102
        TODO: Perhaps callback with the ids and paths as they're added.
 
103
        """
 
104
        if isinstance(files, basestring):
 
105
            # XXX: Passing a single string is inconsistent and should be
 
106
            # deprecated.
 
107
            if not (ids is None or isinstance(ids, basestring)):
 
108
                raise AssertionError()
 
109
            if not (kinds is None or isinstance(kinds, basestring)):
 
110
                raise AssertionError()
 
111
            files = [files]
 
112
            if ids is not None:
 
113
                ids = [ids]
 
114
            if kinds is not None:
 
115
                kinds = [kinds]
 
116
 
 
117
        files = [path.strip('/') for path in files]
 
118
 
 
119
        if ids is None:
 
120
            ids = [None] * len(files)
 
121
        else:
 
122
            if not (len(ids) == len(files)):
 
123
                raise AssertionError()
 
124
        if kinds is None:
 
125
            kinds = [None] * len(files)
 
126
        elif not len(kinds) == len(files):
 
127
            raise AssertionError()
 
128
        for f in files:
 
129
            # generic constraint checks:
 
130
            if self.is_control_filename(f):
 
131
                raise errors.ForbiddenControlFileError(filename=f)
 
132
            fp = splitpath(f)
 
133
        # fill out file kinds for all files [not needed when we stop
 
134
        # caring about the instantaneous file kind within a uncommmitted tree
 
135
        #
 
136
        self._gather_kinds(files, kinds)
 
137
        self._add(files, ids, kinds)
 
138
 
 
139
    def add_reference(self, sub_tree):
 
140
        """Add a TreeReference to the tree, pointing at sub_tree"""
 
141
        raise errors.UnsupportedOperation(self.add_reference, self)
 
142
 
 
143
    def _add_reference(self, sub_tree):
 
144
        """Standard add_reference implementation, for use by subclasses"""
 
145
        try:
 
146
            sub_tree_path = self.relpath(sub_tree.basedir)
 
147
        except errors.PathNotChild:
 
148
            raise errors.BadReferenceTarget(self, sub_tree,
 
149
                                            'Target not inside tree.')
 
150
        sub_tree_id = sub_tree.get_root_id()
 
151
        if sub_tree_id == self.get_root_id():
 
152
            raise errors.BadReferenceTarget(self, sub_tree,
 
153
                                     'Trees have the same root id.')
 
154
        if sub_tree_id in self.inventory:
 
155
            raise errors.BadReferenceTarget(self, sub_tree,
 
156
                                            'Root id already present in tree')
 
157
        self._add([sub_tree_path], [sub_tree_id], ['tree-reference'])
 
158
 
 
159
    def _add(self, files, ids, kinds):
 
160
        """Helper function for add - updates the inventory.
 
161
 
 
162
        :param files: sequence of pathnames, relative to the tree root
 
163
        :param ids: sequence of suggested ids for the files (may be None)
 
164
        :param kinds: sequence of  inventory kinds of the files (i.e. may
 
165
            contain "tree-reference")
 
166
        """
 
167
        raise NotImplementedError(self._add)
 
168
 
 
169
    @needs_tree_write_lock
 
170
    def apply_inventory_delta(self, changes):
 
171
        """Apply changes to the inventory as an atomic operation.
 
172
 
 
173
        :param changes: An inventory delta to apply to the working tree's
 
174
            inventory.
 
175
        :return None:
 
176
        :seealso Inventory.apply_delta: For details on the changes parameter.
 
177
        """
 
178
        self.flush()
 
179
        inv = self.inventory
 
180
        inv.apply_delta(changes)
 
181
        self._write_inventory(inv)
 
182
 
 
183
    @needs_write_lock
 
184
    def commit(self, message=None, revprops=None, *args,
 
185
               **kwargs):
 
186
        # avoid circular imports
 
187
        from bzrlib import commit
 
188
        if revprops is None:
 
189
            revprops = {}
 
190
        possible_master_transports=[]
 
191
        if not 'branch-nick' in revprops:
 
192
            revprops['branch-nick'] = self.branch._get_nick(
 
193
                kwargs.get('local', False),
 
194
                possible_master_transports)
 
195
        authors = kwargs.pop('authors', None)
 
196
        author = kwargs.pop('author', None)
 
197
        if authors is not None:
 
198
            if author is not None:
 
199
                raise AssertionError('Specifying both author and authors '
 
200
                        'is not allowed. Specify just authors instead')
 
201
            if 'author' in revprops or 'authors' in revprops:
 
202
                # XXX: maybe we should just accept one of them?
 
203
                raise AssertionError('author property given twice')
 
204
            if authors:
 
205
                for individual in authors:
 
206
                    if '\n' in individual:
 
207
                        raise AssertionError('\\n is not a valid character '
 
208
                                'in an author identity')
 
209
                revprops['authors'] = '\n'.join(authors)
 
210
        if author is not None:
 
211
            symbol_versioning.warn('The parameter author was deprecated'
 
212
                   ' in version 1.13. Use authors instead',
 
213
                   DeprecationWarning)
 
214
            if 'author' in revprops or 'authors' in revprops:
 
215
                # XXX: maybe we should just accept one of them?
 
216
                raise AssertionError('author property given twice')
 
217
            if '\n' in author:
 
218
                raise AssertionError('\\n is not a valid character '
 
219
                        'in an author identity')
 
220
            revprops['authors'] = author
 
221
        # args for wt.commit start at message from the Commit.commit method,
 
222
        args = (message, ) + args
 
223
        for hook in MutableTree.hooks['start_commit']:
 
224
            hook(self)
 
225
        committed_id = commit.Commit().commit(working_tree=self,
 
226
            revprops=revprops,
 
227
            possible_master_transports=possible_master_transports,
 
228
            *args, **kwargs)
 
229
        return committed_id
 
230
 
 
231
    def _gather_kinds(self, files, kinds):
 
232
        """Helper function for add - sets the entries of kinds."""
 
233
        raise NotImplementedError(self._gather_kinds)
 
234
 
 
235
    def get_file_with_stat(self, file_id, path=None):
 
236
        """Get a file handle and stat object for file_id.
 
237
 
 
238
        The default implementation returns (self.get_file, None) for backwards
 
239
        compatibility.
 
240
 
 
241
        :param file_id: The file id to read.
 
242
        :param path: The path of the file, if it is known.
 
243
        :return: A tuple (file_handle, stat_value_or_None). If the tree has
 
244
            no stat facility, or need for a stat cache feedback during commit,
 
245
            it may return None for the second element of the tuple.
 
246
        """
 
247
        return (self.get_file(file_id, path), None)
 
248
 
 
249
    @needs_read_lock
 
250
    def last_revision(self):
 
251
        """Return the revision id of the last commit performed in this tree.
 
252
 
 
253
        In early tree formats the result of last_revision is the same as the
 
254
        branch last_revision, but that is no longer the case for modern tree
 
255
        formats.
 
256
 
 
257
        last_revision returns the left most parent id, or None if there are no
 
258
        parents.
 
259
 
 
260
        last_revision was deprecated as of 0.11. Please use get_parent_ids
 
261
        instead.
 
262
        """
 
263
        raise NotImplementedError(self.last_revision)
 
264
 
 
265
    def lock_tree_write(self):
 
266
        """Lock the working tree for write, and the branch for read.
 
267
 
 
268
        This is useful for operations which only need to mutate the working
 
269
        tree. Taking out branch write locks is a relatively expensive process
 
270
        and may fail if the branch is on read only media. So branch write locks
 
271
        should only be taken out when we are modifying branch data - such as in
 
272
        operations like commit, pull, uncommit and update.
 
273
        """
 
274
        raise NotImplementedError(self.lock_tree_write)
 
275
 
 
276
    def lock_write(self):
 
277
        """Lock the tree and its branch. This allows mutating calls to be made.
 
278
 
 
279
        Some mutating methods will take out implicit write locks, but in
 
280
        general you should always obtain a write lock before calling mutating
 
281
        methods on a tree.
 
282
        """
 
283
        raise NotImplementedError(self.lock_write)
 
284
 
 
285
    @needs_write_lock
 
286
    def mkdir(self, path, file_id=None):
 
287
        """Create a directory in the tree. if file_id is None, one is assigned.
 
288
 
 
289
        :param path: A unicode file path.
 
290
        :param file_id: An optional file-id.
 
291
        :return: the file id of the new directory.
 
292
        """
 
293
        raise NotImplementedError(self.mkdir)
 
294
 
 
295
    def _observed_sha1(self, file_id, path, (sha1, stat_value)):
 
296
        """Tell the tree we have observed a paths sha1.
 
297
 
 
298
        The intent of this function is to allow trees that have a hashcache to
 
299
        update the hashcache during commit. If the observed file is too new
 
300
        (based on the stat_value) to be safely hash-cached the tree will ignore
 
301
        it.
 
302
 
 
303
        The default implementation does nothing.
 
304
 
 
305
        :param file_id: The file id
 
306
        :param path: The file path
 
307
        :param sha1: The sha 1 that was observed.
 
308
        :param stat_value: A stat result for the file the sha1 was read from.
 
309
        :return: None
 
310
        """
 
311
 
 
312
    def _fix_case_of_inventory_path(self, path):
 
313
        """If our tree isn't case sensitive, return the canonical path"""
 
314
        if not self.case_sensitive:
 
315
            path = self.get_canonical_inventory_path(path)
 
316
        return path
 
317
 
 
318
    @needs_write_lock
 
319
    def put_file_bytes_non_atomic(self, file_id, bytes):
 
320
        """Update the content of a file in the tree.
 
321
 
 
322
        Note that the file is written in-place rather than being
 
323
        written to a temporary location and renamed. As a consequence,
 
324
        readers can potentially see the file half-written.
 
325
 
 
326
        :param file_id: file-id of the file
 
327
        :param bytes: the new file contents
 
328
        """
 
329
        raise NotImplementedError(self.put_file_bytes_non_atomic)
 
330
 
 
331
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
 
332
        """Set the parents ids of the working tree.
 
333
 
 
334
        :param revision_ids: A list of revision_ids.
 
335
        """
 
336
        raise NotImplementedError(self.set_parent_ids)
 
337
 
 
338
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
 
339
        """Set the parents of the working tree.
 
340
 
 
341
        :param parents_list: A list of (revision_id, tree) tuples.
 
342
            If tree is None, then that element is treated as an unreachable
 
343
            parent tree - i.e. a ghost.
 
344
        """
 
345
        raise NotImplementedError(self.set_parent_trees)
 
346
 
 
347
    @needs_tree_write_lock
 
348
    def smart_add(self, file_list, recurse=True, action=None, save=True):
 
349
        """Version file_list, optionally recursing into directories.
 
350
 
 
351
        This is designed more towards DWIM for humans than API clarity.
 
352
        For the specific behaviour see the help for cmd_add().
 
353
 
 
354
        :param action: A reporter to be called with the inventory, parent_ie,
 
355
            path and kind of the path being added. It may return a file_id if
 
356
            a specific one should be used.
 
357
        :param save: Save the inventory after completing the adds. If False
 
358
            this provides dry-run functionality by doing the add and not saving
 
359
            the inventory.
 
360
        :return: A tuple - files_added, ignored_files. files_added is the count
 
361
            of added files, and ignored_files is a dict mapping files that were
 
362
            ignored to the rule that caused them to be ignored.
 
363
        """
 
364
        # not in an inner loop; and we want to remove direct use of this,
 
365
        # so here as a reminder for now. RBC 20070703
 
366
        from bzrlib.inventory import InventoryEntry
 
367
        if action is None:
 
368
            action = add.AddAction()
 
369
 
 
370
        if not file_list:
 
371
            # no paths supplied: add the entire tree.
 
372
            file_list = [u'.']
 
373
        # mutter("smart add of %r")
 
374
        inv = self.inventory
 
375
        added = []
 
376
        ignored = {}
 
377
        dirs_to_add = []
 
378
        user_dirs = set()
 
379
 
 
380
        # validate user file paths and convert all paths to tree
 
381
        # relative : it's cheaper to make a tree relative path an abspath
 
382
        # than to convert an abspath to tree relative, and it's cheaper to
 
383
        # perform the canonicalization in bulk.
 
384
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
 
385
            rf = _FastPath(filepath)
 
386
            # validate user parameters. Our recursive code avoids adding new files
 
387
            # that need such validation
 
388
            if self.is_control_filename(rf.raw_path):
 
389
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
 
390
 
 
391
            abspath = self.abspath(rf.raw_path)
 
392
            kind = osutils.file_kind(abspath)
 
393
            if kind == 'directory':
 
394
                # schedule the dir for scanning
 
395
                user_dirs.add(rf)
 
396
            else:
 
397
                if not InventoryEntry.versionable_kind(kind):
 
398
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
 
399
            # ensure the named path is added, so that ignore rules in the later directory
 
400
            # walk dont skip it.
 
401
            # we dont have a parent ie known yet.: use the relatively slower inventory
 
402
            # probing method
 
403
            versioned = inv.has_filename(rf.raw_path)
 
404
            if versioned:
 
405
                continue
 
406
            added.extend(_add_one_and_parent(self, inv, None, rf, kind, action))
 
407
 
 
408
        if not recurse:
 
409
            # no need to walk any directories at all.
 
410
            if len(added) > 0 and save:
 
411
                self._write_inventory(inv)
 
412
            return added, ignored
 
413
 
 
414
        # only walk the minimal parents needed: we have user_dirs to override
 
415
        # ignores.
 
416
        prev_dir = None
 
417
 
 
418
        is_inside = osutils.is_inside_or_parent_of_any
 
419
        for path in sorted(user_dirs):
 
420
            if (prev_dir is None or not is_inside([prev_dir], path.raw_path)):
 
421
                dirs_to_add.append((path, None))
 
422
            prev_dir = path.raw_path
 
423
 
 
424
        # dirs_to_add is initialised to a list of directories, but as we scan
 
425
        # directories we append files to it.
 
426
        # XXX: We should determine kind of files when we scan them rather than
 
427
        # adding to this list. RBC 20070703
 
428
        for directory, parent_ie in dirs_to_add:
 
429
            # directory is tree-relative
 
430
            abspath = self.abspath(directory.raw_path)
 
431
 
 
432
            # get the contents of this directory.
 
433
 
 
434
            # find the kind of the path being added.
 
435
            kind = osutils.file_kind(abspath)
 
436
 
 
437
            if not InventoryEntry.versionable_kind(kind):
 
438
                warning("skipping %s (can't add file of kind '%s')", abspath, kind)
 
439
                continue
 
440
 
 
441
            if parent_ie is not None:
 
442
                versioned = directory.base_path in parent_ie.children
 
443
            else:
 
444
                # without the parent ie, use the relatively slower inventory
 
445
                # probing method
 
446
                versioned = inv.has_filename(
 
447
                        self._fix_case_of_inventory_path(directory.raw_path))
 
448
 
 
449
            if kind == 'directory':
 
450
                try:
 
451
                    sub_branch = bzrdir.BzrDir.open(abspath)
 
452
                    sub_tree = True
 
453
                except errors.NotBranchError:
 
454
                    sub_tree = False
 
455
                except errors.UnsupportedFormatError:
 
456
                    sub_tree = True
 
457
            else:
 
458
                sub_tree = False
 
459
 
 
460
            if directory.raw_path == '':
 
461
                # mutter("tree root doesn't need to be added")
 
462
                sub_tree = False
 
463
            elif versioned:
 
464
                pass
 
465
                # mutter("%r is already versioned", abspath)
 
466
            elif sub_tree:
 
467
                # XXX: This is wrong; people *might* reasonably be trying to add
 
468
                # subtrees as subtrees.  This should probably only be done in formats
 
469
                # which can represent subtrees, and even then perhaps only when
 
470
                # the user asked to add subtrees.  At the moment you can add them
 
471
                # specially through 'join --reference', which is perhaps
 
472
                # reasonable: adding a new reference is a special operation and
 
473
                # can have a special behaviour.  mbp 20070306
 
474
                mutter("%r is a nested bzr tree", abspath)
 
475
            else:
 
476
                _add_one(self, inv, parent_ie, directory, kind, action)
 
477
                added.append(directory.raw_path)
 
478
 
 
479
            if kind == 'directory' and not sub_tree:
 
480
                if parent_ie is not None:
 
481
                    # must be present:
 
482
                    this_ie = parent_ie.children[directory.base_path]
 
483
                else:
 
484
                    # without the parent ie, use the relatively slower inventory
 
485
                    # probing method
 
486
                    this_id = inv.path2id(
 
487
                            self._fix_case_of_inventory_path(directory.raw_path))
 
488
                    if this_id is None:
 
489
                        this_ie = None
 
490
                    else:
 
491
                        this_ie = inv[this_id]
 
492
 
 
493
                for subf in sorted(os.listdir(abspath)):
 
494
                    # here we could use TreeDirectory rather than
 
495
                    # string concatenation.
 
496
                    subp = osutils.pathjoin(directory.raw_path, subf)
 
497
                    # TODO: is_control_filename is very slow. Make it faster.
 
498
                    # TreeDirectory.is_control_filename could also make this
 
499
                    # faster - its impossible for a non root dir to have a
 
500
                    # control file.
 
501
                    if self.is_control_filename(subp):
 
502
                        mutter("skip control directory %r", subp)
 
503
                    elif subf in this_ie.children:
 
504
                        # recurse into this already versioned subdir.
 
505
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
 
506
                    else:
 
507
                        # user selection overrides ignoes
 
508
                        # ignore while selecting files - if we globbed in the
 
509
                        # outer loop we would ignore user files.
 
510
                        ignore_glob = self.is_ignored(subp)
 
511
                        if ignore_glob is not None:
 
512
                            # mutter("skip ignored sub-file %r", subp)
 
513
                            ignored.setdefault(ignore_glob, []).append(subp)
 
514
                        else:
 
515
                            #mutter("queue to add sub-file %r", subp)
 
516
                            dirs_to_add.append((_FastPath(subp, subf), this_ie))
 
517
 
 
518
        if len(added) > 0:
 
519
            if save:
 
520
                self._write_inventory(inv)
 
521
            else:
 
522
                self.read_working_inventory()
 
523
        return added, ignored
 
524
 
 
525
    def update_basis_by_delta(self, new_revid, delta):
 
526
        """Update the parents of this tree after a commit.
 
527
 
 
528
        This gives the tree one parent, with revision id new_revid. The
 
529
        inventory delta is applied to the current basis tree to generate the
 
530
        inventory for the parent new_revid, and all other parent trees are
 
531
        discarded.
 
532
 
 
533
        All the changes in the delta should be changes synchronising the basis
 
534
        tree with some or all of the working tree, with a change to a directory
 
535
        requiring that its contents have been recursively included. That is,
 
536
        this is not a general purpose tree modification routine, but a helper
 
537
        for commit which is not required to handle situations that do not arise
 
538
        outside of commit.
 
539
 
 
540
        :param new_revid: The new revision id for the trees parent.
 
541
        :param delta: An inventory delta (see apply_inventory_delta) describing
 
542
            the changes from the current left most parent revision to new_revid.
 
543
        """
 
544
        # if the tree is updated by a pull to the branch, as happens in
 
545
        # WorkingTree2, when there was no separation between branch and tree,
 
546
        # then just clear merges, efficiency is not a concern for now as this
 
547
        # is legacy environments only, and they are slow regardless.
 
548
        if self.last_revision() == new_revid:
 
549
            self.set_parent_ids([new_revid])
 
550
            return
 
551
        # generic implementation based on Inventory manipulation. See
 
552
        # WorkingTree classes for optimised versions for specific format trees.
 
553
        basis = self.basis_tree()
 
554
        basis.lock_read()
 
555
        inventory = basis.inventory
 
556
        basis.unlock()
 
557
        inventory.apply_delta(delta)
 
558
        rev_tree = RevisionTree(self.branch.repository, inventory, new_revid)
 
559
        self.set_parent_trees([(new_revid, rev_tree)])
 
560
 
 
561
 
 
562
class MutableTreeHooks(hooks.Hooks):
 
563
    """A dictionary mapping a hook name to a list of callables for mutabletree
 
564
    hooks.
 
565
    """
 
566
 
 
567
    def __init__(self):
 
568
        """Create the default hooks.
 
569
 
 
570
        """
 
571
        hooks.Hooks.__init__(self)
 
572
        self.create_hook(hooks.HookPoint('start_commit',
 
573
            "Called before a commit is performed on a tree. The start commit "
 
574
            "hook is able to change the tree before the commit takes place. "
 
575
            "start_commit is called with the bzrlib.tree.MutableTree that the "
 
576
            "commit is being performed on.", (1, 4), None))
 
577
 
 
578
 
 
579
# install the default hooks into the MutableTree class.
 
580
MutableTree.hooks = MutableTreeHooks()
 
581
 
 
582
 
 
583
class _FastPath(object):
 
584
    """A path object with fast accessors for things like basename."""
 
585
 
 
586
    __slots__ = ['raw_path', 'base_path']
 
587
 
 
588
    def __init__(self, path, base_path=None):
 
589
        """Construct a FastPath from path."""
 
590
        if base_path is None:
 
591
            self.base_path = osutils.basename(path)
 
592
        else:
 
593
            self.base_path = base_path
 
594
        self.raw_path = path
 
595
 
 
596
    def __cmp__(self, other):
 
597
        return cmp(self.raw_path, other.raw_path)
 
598
 
 
599
    def __hash__(self):
 
600
        return hash(self.raw_path)
 
601
 
 
602
 
 
603
def _add_one_and_parent(tree, inv, parent_ie, path, kind, action):
 
604
    """Add a new entry to the inventory and automatically add unversioned parents.
 
605
 
 
606
    :param inv: Inventory which will receive the new entry.
 
607
    :param parent_ie: Parent inventory entry if known, or None.  If
 
608
        None, the parent is looked up by name and used if present, otherwise it
 
609
        is recursively added.
 
610
    :param kind: Kind of new entry (file, directory, etc)
 
611
    :param action: callback(inv, parent_ie, path, kind); return ignored.
 
612
    :return: A list of paths which have been added.
 
613
    """
 
614
    # Nothing to do if path is already versioned.
 
615
    # This is safe from infinite recursion because the tree root is
 
616
    # always versioned.
 
617
    if parent_ie is not None:
 
618
        # we have a parent ie already
 
619
        added = []
 
620
    else:
 
621
        # slower but does not need parent_ie
 
622
        if inv.has_filename(tree._fix_case_of_inventory_path(path.raw_path)):
 
623
            return []
 
624
        # its really not there : add the parent
 
625
        # note that the dirname use leads to some extra str copying etc but as
 
626
        # there are a limited number of dirs we can be nested under, it should
 
627
        # generally find it very fast and not recurse after that.
 
628
        added = _add_one_and_parent(tree, inv, None,
 
629
            _FastPath(dirname(path.raw_path)), 'directory', action)
 
630
        parent_id = inv.path2id(dirname(path.raw_path))
 
631
        parent_ie = inv[parent_id]
 
632
    _add_one(tree, inv, parent_ie, path, kind, action)
 
633
    return added + [path.raw_path]
 
634
 
 
635
 
 
636
def _add_one(tree, inv, parent_ie, path, kind, file_id_callback):
 
637
    """Add a new entry to the inventory.
 
638
 
 
639
    :param inv: Inventory which will receive the new entry.
 
640
    :param parent_ie: Parent inventory entry.
 
641
    :param kind: Kind of new entry (file, directory, etc)
 
642
    :param file_id_callback: callback(inv, parent_ie, path, kind); return a
 
643
        file_id or None to generate a new file id
 
644
    :returns: None
 
645
    """
 
646
    file_id = file_id_callback(inv, parent_ie, path, kind)
 
647
    entry = inv.make_entry(kind, path.base_path, parent_ie.file_id,
 
648
        file_id=file_id)
 
649
    inv.add(entry)