~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Alexander Belchenko
  • Date: 2006-07-30 16:43:12 UTC
  • mto: (1711.2.111 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1906.
  • Revision ID: bialix@ukr.net-20060730164312-b025fd3ff0cee59e
rename  gpl.txt => COPYING.txt

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