/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/mutabletree.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
19
19
See MutableTree for more details.
20
20
"""
21
21
 
22
 
from __future__ import absolute_import
23
 
 
24
 
from . import (
 
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,
25
31
    errors,
26
32
    hooks,
27
33
    osutils,
 
34
    revisiontree,
 
35
    symbol_versioning,
28
36
    trace,
29
37
    tree,
30
38
    )
31
 
 
32
 
from .sixish import (
33
 
    text_type,
34
 
    )
35
 
 
36
 
 
37
 
class BadReferenceTarget(errors.InternalBzrError):
38
 
 
39
 
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
40
 
           "%(reason)s"
41
 
 
42
 
    def __init__(self, tree, other_tree, reason):
43
 
        self.tree = tree
44
 
        self.other_tree = other_tree
45
 
        self.reason = reason
 
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
46
55
 
47
56
 
48
57
class MutableTree(tree.Tree):
52
61
    context, and will revert if the lock is broken abnormally - but this cannot
53
62
    be guaranteed - depending on the exact implementation of the mutable state.
54
63
 
55
 
    The most common form of Mutable Tree is WorkingTree, see breezy.workingtree.
 
64
    The most common form of Mutable Tree is WorkingTree, see bzrlib.workingtree.
56
65
    For tests we also have MemoryTree which is a MutableTree whose contents are
57
66
    entirely in memory.
58
67
 
60
69
    conformance tests for - rather we are testing MemoryTree specifically, and
61
70
    interface testing implementations of WorkingTree.
62
71
 
63
 
    A mutable tree always has an associated Branch and ControlDir object - the
 
72
    A mutable tree always has an associated Branch and BzrDir object - the
64
73
    branch and bzrdir attributes.
65
74
    """
66
 
 
67
75
    def __init__(self, *args, **kw):
68
76
        super(MutableTree, self).__init__(*args, **kw)
69
77
        # Is this tree on a case-insensitive or case-preserving file-system?
71
79
        # used on media which doesn't differentiate the case of names.
72
80
        self.case_sensitive = True
73
81
 
74
 
    def is_control_filename(self, filename):
75
 
        """True if filename is the name of a control file in this tree.
76
 
 
77
 
        :param filename: A filename within the tree. This is a relative path
78
 
            from the root of this tree.
79
 
 
80
 
        This is true IF and ONLY IF the filename is part of the meta data
81
 
        that bzr controls in this tree. I.E. a random .bzr directory placed
82
 
        on disk will not be a control file for this tree.
83
 
        """
84
 
        raise NotImplementedError(self.is_control_filename)
85
 
 
 
82
    @needs_tree_write_lock
86
83
    def add(self, files, ids=None, kinds=None):
87
84
        """Add paths to the set of versioned paths.
88
85
 
89
86
        Note that the command line normally calls smart_add instead,
90
87
        which can automatically recurse.
91
88
 
92
 
        This adds the files to the tree, so that they will be
 
89
        This adds the files to the inventory, so that they will be
93
90
        recorded by the next commit.
94
91
 
95
92
        :param files: List of paths to add, relative to the base of the tree.
101
98
 
102
99
        TODO: Perhaps callback with the ids and paths as they're added.
103
100
        """
104
 
        if isinstance(files, (str, text_type)):
 
101
        if isinstance(files, basestring):
105
102
            # XXX: Passing a single string is inconsistent and should be
106
103
            # deprecated.
107
 
            if not (ids is None or isinstance(ids, bytes)):
 
104
            if not (ids is None or isinstance(ids, basestring)):
108
105
                raise AssertionError()
109
 
            if not (kinds is None or isinstance(kinds, (str, text_type))):
 
106
            if not (kinds is None or isinstance(kinds, basestring)):
110
107
                raise AssertionError()
111
108
            files = [files]
112
109
            if ids is not None:
125
122
            kinds = [None] * len(files)
126
123
        elif not len(kinds) == len(files):
127
124
            raise AssertionError()
128
 
        with self.lock_tree_write():
129
 
            for f in files:
130
 
                # generic constraint checks:
131
 
                if self.is_control_filename(f):
132
 
                    raise errors.ForbiddenControlFileError(filename=f)
133
 
                fp = osutils.splitpath(f)
134
 
            # fill out file kinds for all files [not needed when we stop
135
 
            # caring about the instantaneous file kind within a uncommmitted tree
136
 
            #
137
 
            self._gather_kinds(files, kinds)
138
 
            self._add(files, ids, kinds)
 
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)
139
135
 
140
136
    def add_reference(self, sub_tree):
141
 
        """Add a TreeReference to the tree, pointing at sub_tree.
142
 
 
143
 
        :param sub_tree: subtree to add.
144
 
        """
 
137
        """Add a TreeReference to the tree, pointing at sub_tree"""
145
138
        raise errors.UnsupportedOperation(self.add_reference, self)
146
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
 
147
156
    def _add(self, files, ids, kinds):
148
157
        """Helper function for add - updates the inventory.
149
158
 
154
163
        """
155
164
        raise NotImplementedError(self._add)
156
165
 
157
 
    def commit(self, message=None, revprops=None, *args, **kwargs):
 
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):
158
183
        # avoid circular imports
159
 
        from breezy import commit
160
 
        possible_master_transports = []
161
 
        with self.lock_write():
162
 
            revprops = commit.Commit.update_revprops(
163
 
                revprops,
164
 
                self.branch,
165
 
                kwargs.pop('authors', None),
 
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(
166
190
                kwargs.get('local', False),
167
191
                possible_master_transports)
168
 
            # args for wt.commit start at message from the Commit.commit method,
169
 
            args = (message, ) + args
170
 
            for hook in MutableTree.hooks['start_commit']:
171
 
                hook(self)
172
 
            committed_id = commit.Commit().commit(working_tree=self,
173
 
                                                  revprops=revprops,
174
 
                                                  possible_master_transports=possible_master_transports,
175
 
                                                  *args, **kwargs)
176
 
            post_hook_params = PostCommitHookParams(self)
177
 
            for hook in MutableTree.hooks['post_commit']:
178
 
                hook(post_hook_params)
179
 
            return committed_id
 
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
180
230
 
181
231
    def _gather_kinds(self, files, kinds):
182
232
        """Helper function for add - sets the entries of kinds."""
183
233
        raise NotImplementedError(self._gather_kinds)
184
234
 
 
235
    @needs_read_lock
185
236
    def has_changes(self, _from_tree=None):
186
237
        """Quickly check that the tree contains at least one commitable change.
187
238
 
190
241
 
191
242
        :return: True if a change is found. False otherwise
192
243
        """
193
 
        with self.lock_read():
194
 
            # Check pending merges
195
 
            if len(self.get_parent_ids()) > 1:
196
 
                return True
197
 
            if _from_tree is None:
198
 
                _from_tree = self.basis_tree()
199
 
            changes = self.iter_changes(_from_tree)
200
 
            try:
201
 
                change = next(changes)
202
 
                # Exclude root (talk about black magic... --vila 20090629)
203
 
                if change[4] == (None, None):
204
 
                    change = next(changes)
205
 
                return True
206
 
            except StopIteration:
207
 
                # No changes
208
 
                return False
 
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
209
259
 
 
260
    @needs_read_lock
210
261
    def check_changed_or_out_of_date(self, strict, opt_name,
211
262
                                     more_error, more_warning):
212
263
        """Check the tree for uncommitted changes and branch synchronization.
223
274
 
224
275
        :param more_warning: Details about what is happening.
225
276
        """
226
 
        with self.lock_read():
227
 
            if strict is None:
228
 
                strict = self.branch.get_config_stack().get(opt_name)
229
 
            if strict is not False:
230
 
                err_class = None
231
 
                if (self.has_changes()):
232
 
                    err_class = errors.UncommittedChanges
233
 
                elif self.last_revision() != self.branch.last_revision():
234
 
                    # The tree has lost sync with its branch, there is little
235
 
                    # chance that the user is aware of it but he can still
236
 
                    # force the action with --no-strict
237
 
                    err_class = errors.OutOfDateTree
238
 
                if err_class is not None:
239
 
                    if strict is None:
240
 
                        err = err_class(self, more=more_warning)
241
 
                        # We don't want to interrupt the user if he expressed
242
 
                        # no preference about strict.
243
 
                        trace.warning('%s', err._format())
244
 
                    else:
245
 
                        err = err_class(self, more=more_error)
246
 
                        raise err
 
277
        if strict is None:
 
278
            strict = self.branch.get_config().get_user_option_as_bool(opt_name)
 
279
        if strict is not False:
 
280
            err_class = None
 
281
            if (self.has_changes()):
 
282
                err_class = errors.UncommittedChanges
 
283
            elif self.last_revision() != self.branch.last_revision():
 
284
                # The tree has lost sync with its branch, there is little
 
285
                # chance that the user is aware of it but he can still force
 
286
                # the action with --no-strict
 
287
                err_class = errors.OutOfDateTree
 
288
            if err_class is not None:
 
289
                if strict is None:
 
290
                    err = err_class(self, more=more_warning)
 
291
                    # We don't want to interrupt the user if he expressed no
 
292
                    # preference about strict.
 
293
                    trace.warning('%s', err._format())
 
294
                else:
 
295
                    err = err_class(self, more=more_error)
 
296
                    raise err
247
297
 
 
298
    @needs_read_lock
248
299
    def last_revision(self):
249
300
        """Return the revision id of the last commit performed in this tree.
250
301
 
280
331
        """
281
332
        raise NotImplementedError(self.lock_write)
282
333
 
 
334
    @needs_write_lock
283
335
    def mkdir(self, path, file_id=None):
284
336
        """Create a directory in the tree. if file_id is None, one is assigned.
285
337
 
289
341
        """
290
342
        raise NotImplementedError(self.mkdir)
291
343
 
292
 
    def _observed_sha1(self, path, sha_and_stat):
 
344
    def _observed_sha1(self, file_id, path, (sha1, stat_value)):
293
345
        """Tell the tree we have observed a paths sha1.
294
346
 
295
347
        The intent of this function is to allow trees that have a hashcache to
299
351
 
300
352
        The default implementation does nothing.
301
353
 
 
354
        :param file_id: The file id
302
355
        :param path: The file path
303
 
        :param sha_and_stat: The sha 1 and stat result observed.
 
356
        :param sha1: The sha 1 that was observed.
 
357
        :param stat_value: A stat result for the file the sha1 was read from.
304
358
        :return: None
305
359
        """
306
360
 
307
 
    def put_file_bytes_non_atomic(self, path, bytes):
 
361
    def _fix_case_of_inventory_path(self, path):
 
362
        """If our tree isn't case sensitive, return the canonical path"""
 
363
        if not self.case_sensitive:
 
364
            path = self.get_canonical_inventory_path(path)
 
365
        return path
 
366
 
 
367
    @needs_write_lock
 
368
    def put_file_bytes_non_atomic(self, file_id, bytes):
308
369
        """Update the content of a file in the tree.
309
370
 
310
371
        Note that the file is written in-place rather than being
332
393
        """
333
394
        raise NotImplementedError(self.set_parent_trees)
334
395
 
 
396
    @needs_tree_write_lock
335
397
    def smart_add(self, file_list, recurse=True, action=None, save=True):
336
398
        """Version file_list, optionally recursing into directories.
337
399
 
338
400
        This is designed more towards DWIM for humans than API clarity.
339
401
        For the specific behaviour see the help for cmd_add().
340
402
 
341
 
        :param file_list: List of zero or more paths.  *NB: these are
342
 
            interpreted relative to the process cwd, not relative to the
343
 
            tree.*  (Add and most other tree methods use tree-relative
344
 
            paths.)
345
 
        :param action: A reporter to be called with the working tree, parent_ie,
 
403
        :param action: A reporter to be called with the inventory, parent_ie,
346
404
            path and kind of the path being added. It may return a file_id if
347
405
            a specific one should be used.
348
 
        :param save: Save the changes after completing the adds. If False
 
406
        :param save: Save the inventory after completing the adds. If False
349
407
            this provides dry-run functionality by doing the add and not saving
350
 
            the changes.
 
408
            the inventory.
351
409
        :return: A tuple - files_added, ignored_files. files_added is the count
352
410
            of added files, and ignored_files is a dict mapping files that were
353
411
            ignored to the rule that caused them to be ignored.
354
412
        """
355
 
        raise NotImplementedError(self.smart_add)
356
 
 
357
 
    def rename_one(self, from_rel, to_rel, after=False):
358
 
        """Rename one file.
359
 
 
360
 
        This can change the directory or the filename or both.
361
 
 
362
 
        rename_one has several 'modes' to work. First, it can rename a physical
363
 
        file and change the file_id. That is the normal mode. Second, it can
364
 
        only change the file_id without touching any physical file.
365
 
 
366
 
        rename_one uses the second mode if 'after == True' and 'to_rel' is
367
 
        either not versioned or newly added, and present in the working tree.
368
 
 
369
 
        rename_one uses the second mode if 'after == False' and 'from_rel' is
370
 
        versioned but no longer in the working tree, and 'to_rel' is not
371
 
        versioned but present in the working tree.
372
 
 
373
 
        rename_one uses the first mode if 'after == False' and 'from_rel' is
374
 
        versioned and present in the working tree, and 'to_rel' is not
375
 
        versioned and not present in the working tree.
376
 
 
377
 
        Everything else results in an error.
378
 
        """
379
 
        raise NotImplementedError(self.rename_one)
380
 
 
381
 
    def copy_one(self, from_rel, to_rel):
382
 
        """Copy one file or directory.
383
 
 
384
 
        This can change the directory or the filename or both.
385
 
 
386
 
        """
387
 
        raise NotImplementedError(self.copy_one)
 
413
        # not in an inner loop; and we want to remove direct use of this,
 
414
        # so here as a reminder for now. RBC 20070703
 
415
        from bzrlib.inventory import InventoryEntry
 
416
        if action is None:
 
417
            action = add.AddAction()
 
418
 
 
419
        if not file_list:
 
420
            # no paths supplied: add the entire tree.
 
421
            # FIXME: this assumes we are running in a working tree subdir :-/
 
422
            # -- vila 20100208
 
423
            file_list = [u'.']
 
424
        # mutter("smart add of %r")
 
425
        inv = self.inventory
 
426
        added = []
 
427
        ignored = {}
 
428
        dirs_to_add = []
 
429
        user_dirs = set()
 
430
        conflicts_related = set()
 
431
        # Not all mutable trees can have conflicts
 
432
        if getattr(self, 'conflicts', None) is not None:
 
433
            # Collect all related files without checking whether they exist or
 
434
            # are versioned. It's cheaper to do that once for all conflicts
 
435
            # than trying to find the relevant conflict for each added file.
 
436
            for c in self.conflicts():
 
437
                conflicts_related.update(c.associated_filenames())
 
438
 
 
439
        # validate user file paths and convert all paths to tree
 
440
        # relative : it's cheaper to make a tree relative path an abspath
 
441
        # than to convert an abspath to tree relative, and it's cheaper to
 
442
        # perform the canonicalization in bulk.
 
443
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
 
444
            rf = _FastPath(filepath)
 
445
            # validate user parameters. Our recursive code avoids adding new
 
446
            # files that need such validation
 
447
            if self.is_control_filename(rf.raw_path):
 
448
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
 
449
 
 
450
            abspath = self.abspath(rf.raw_path)
 
451
            kind = osutils.file_kind(abspath)
 
452
            if kind == 'directory':
 
453
                # schedule the dir for scanning
 
454
                user_dirs.add(rf)
 
455
            else:
 
456
                if not InventoryEntry.versionable_kind(kind):
 
457
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
 
458
            # ensure the named path is added, so that ignore rules in the later
 
459
            # directory walk dont skip it.
 
460
            # we dont have a parent ie known yet.: use the relatively slower
 
461
            # inventory probing method
 
462
            versioned = inv.has_filename(rf.raw_path)
 
463
            if versioned:
 
464
                continue
 
465
            added.extend(_add_one_and_parent(self, inv, None, rf, kind, action))
 
466
 
 
467
        if not recurse:
 
468
            # no need to walk any directories at all.
 
469
            if len(added) > 0 and save:
 
470
                self._write_inventory(inv)
 
471
            return added, ignored
 
472
 
 
473
        # only walk the minimal parents needed: we have user_dirs to override
 
474
        # ignores.
 
475
        prev_dir = None
 
476
 
 
477
        is_inside = osutils.is_inside_or_parent_of_any
 
478
        for path in sorted(user_dirs):
 
479
            if (prev_dir is None or not is_inside([prev_dir], path.raw_path)):
 
480
                dirs_to_add.append((path, None))
 
481
            prev_dir = path.raw_path
 
482
 
 
483
        illegalpath_re = re.compile(r'[\r\n]')
 
484
        # dirs_to_add is initialised to a list of directories, but as we scan
 
485
        # directories we append files to it.
 
486
        # XXX: We should determine kind of files when we scan them rather than
 
487
        # adding to this list. RBC 20070703
 
488
        for directory, parent_ie in dirs_to_add:
 
489
            # directory is tree-relative
 
490
            abspath = self.abspath(directory.raw_path)
 
491
 
 
492
            # get the contents of this directory.
 
493
 
 
494
            # find the kind of the path being added.
 
495
            kind = osutils.file_kind(abspath)
 
496
 
 
497
            if not InventoryEntry.versionable_kind(kind):
 
498
                trace.warning("skipping %s (can't add file of kind '%s')",
 
499
                              abspath, kind)
 
500
                continue
 
501
            if illegalpath_re.search(directory.raw_path):
 
502
                trace.warning("skipping %r (contains \\n or \\r)" % abspath)
 
503
                continue
 
504
            if directory.raw_path in conflicts_related:
 
505
                # If the file looks like one generated for a conflict, don't
 
506
                # add it.
 
507
                trace.warning(
 
508
                    'skipping %s (generated to help resolve conflicts)',
 
509
                    abspath)
 
510
                continue
 
511
 
 
512
            if parent_ie is not None:
 
513
                versioned = directory.base_path in parent_ie.children
 
514
            else:
 
515
                # without the parent ie, use the relatively slower inventory
 
516
                # probing method
 
517
                versioned = inv.has_filename(
 
518
                        self._fix_case_of_inventory_path(directory.raw_path))
 
519
 
 
520
            if kind == 'directory':
 
521
                try:
 
522
                    sub_branch = bzrdir.BzrDir.open(abspath)
 
523
                    sub_tree = True
 
524
                except errors.NotBranchError:
 
525
                    sub_tree = False
 
526
                except errors.UnsupportedFormatError:
 
527
                    sub_tree = True
 
528
            else:
 
529
                sub_tree = False
 
530
 
 
531
            if directory.raw_path == '':
 
532
                # mutter("tree root doesn't need to be added")
 
533
                sub_tree = False
 
534
            elif versioned:
 
535
                pass
 
536
                # mutter("%r is already versioned", abspath)
 
537
            elif sub_tree:
 
538
                # XXX: This is wrong; people *might* reasonably be trying to
 
539
                # add subtrees as subtrees.  This should probably only be done
 
540
                # in formats which can represent subtrees, and even then
 
541
                # perhaps only when the user asked to add subtrees.  At the
 
542
                # moment you can add them specially through 'join --reference',
 
543
                # which is perhaps reasonable: adding a new reference is a
 
544
                # special operation and can have a special behaviour.  mbp
 
545
                # 20070306
 
546
                trace.mutter("%r is a nested bzr tree", abspath)
 
547
            else:
 
548
                _add_one(self, inv, parent_ie, directory, kind, action)
 
549
                added.append(directory.raw_path)
 
550
 
 
551
            if kind == 'directory' and not sub_tree:
 
552
                if parent_ie is not None:
 
553
                    # must be present:
 
554
                    this_ie = parent_ie.children[directory.base_path]
 
555
                else:
 
556
                    # without the parent ie, use the relatively slower inventory
 
557
                    # probing method
 
558
                    this_id = inv.path2id(
 
559
                        self._fix_case_of_inventory_path(directory.raw_path))
 
560
                    if this_id is None:
 
561
                        this_ie = None
 
562
                    else:
 
563
                        this_ie = inv[this_id]
 
564
 
 
565
                for subf in sorted(os.listdir(abspath)):
 
566
                    # here we could use TreeDirectory rather than
 
567
                    # string concatenation.
 
568
                    subp = osutils.pathjoin(directory.raw_path, subf)
 
569
                    # TODO: is_control_filename is very slow. Make it faster.
 
570
                    # TreeDirectory.is_control_filename could also make this
 
571
                    # faster - its impossible for a non root dir to have a
 
572
                    # control file.
 
573
                    if self.is_control_filename(subp):
 
574
                        trace.mutter("skip control directory %r", subp)
 
575
                    elif subf in this_ie.children:
 
576
                        # recurse into this already versioned subdir.
 
577
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
 
578
                    else:
 
579
                        # user selection overrides ignoes
 
580
                        # ignore while selecting files - if we globbed in the
 
581
                        # outer loop we would ignore user files.
 
582
                        ignore_glob = self.is_ignored(subp)
 
583
                        if ignore_glob is not None:
 
584
                            # mutter("skip ignored sub-file %r", subp)
 
585
                            ignored.setdefault(ignore_glob, []).append(subp)
 
586
                        else:
 
587
                            #mutter("queue to add sub-file %r", subp)
 
588
                            dirs_to_add.append((_FastPath(subp, subf), this_ie))
 
589
 
 
590
        if len(added) > 0:
 
591
            if save:
 
592
                self._write_inventory(inv)
 
593
            else:
 
594
                self.read_working_inventory()
 
595
        return added, ignored
 
596
 
 
597
    def update_basis_by_delta(self, new_revid, delta):
 
598
        """Update the parents of this tree after a commit.
 
599
 
 
600
        This gives the tree one parent, with revision id new_revid. The
 
601
        inventory delta is applied to the current basis tree to generate the
 
602
        inventory for the parent new_revid, and all other parent trees are
 
603
        discarded.
 
604
 
 
605
        All the changes in the delta should be changes synchronising the basis
 
606
        tree with some or all of the working tree, with a change to a directory
 
607
        requiring that its contents have been recursively included. That is,
 
608
        this is not a general purpose tree modification routine, but a helper
 
609
        for commit which is not required to handle situations that do not arise
 
610
        outside of commit.
 
611
 
 
612
        See the inventory developers documentation for the theory behind
 
613
        inventory deltas.
 
614
 
 
615
        :param new_revid: The new revision id for the trees parent.
 
616
        :param delta: An inventory delta (see apply_inventory_delta) describing
 
617
            the changes from the current left most parent revision to new_revid.
 
618
        """
 
619
        # if the tree is updated by a pull to the branch, as happens in
 
620
        # WorkingTree2, when there was no separation between branch and tree,
 
621
        # then just clear merges, efficiency is not a concern for now as this
 
622
        # is legacy environments only, and they are slow regardless.
 
623
        if self.last_revision() == new_revid:
 
624
            self.set_parent_ids([new_revid])
 
625
            return
 
626
        # generic implementation based on Inventory manipulation. See
 
627
        # WorkingTree classes for optimised versions for specific format trees.
 
628
        basis = self.basis_tree()
 
629
        basis.lock_read()
 
630
        # TODO: Consider re-evaluating the need for this with CHKInventory
 
631
        # we don't strictly need to mutate an inventory for this
 
632
        # it only makes sense when apply_delta is cheaper than get_inventory()
 
633
        inventory = basis.inventory._get_mutable_inventory()
 
634
        basis.unlock()
 
635
        inventory.apply_delta(delta)
 
636
        rev_tree = revisiontree.RevisionTree(self.branch.repository,
 
637
                                             inventory, new_revid)
 
638
        self.set_parent_trees([(new_revid, rev_tree)])
388
639
 
389
640
 
390
641
class MutableTreeHooks(hooks.Hooks):
396
647
        """Create the default hooks.
397
648
 
398
649
        """
399
 
        hooks.Hooks.__init__(self, "breezy.mutabletree", "MutableTree.hooks")
400
 
        self.add_hook('start_commit',
401
 
                      "Called before a commit is performed on a tree. The start commit "
402
 
                      "hook is able to change the tree before the commit takes place. "
403
 
                      "start_commit is called with the breezy.mutabletree.MutableTree "
404
 
                      "that the commit is being performed on.", (1, 4))
405
 
        self.add_hook('post_commit',
406
 
                      "Called after a commit is performed on a tree. The hook is "
407
 
                      "called with a breezy.mutabletree.PostCommitHookParams object. "
408
 
                      "The mutable tree the commit was performed on is available via "
409
 
                      "the mutable_tree attribute of that object.", (2, 0))
410
 
        self.add_hook('pre_transform',
411
 
                      "Called before a tree transform on this tree. The hook is called "
412
 
                      "with the tree that is being transformed and the transform.",
413
 
                      (2, 5))
414
 
        self.add_hook('post_build_tree',
415
 
                      "Called after a completely new tree is built. The hook is "
416
 
                      "called with the tree as its only argument.", (2, 5))
417
 
        self.add_hook('post_transform',
418
 
                      "Called after a tree transform has been performed on a tree. "
419
 
                      "The hook is called with the tree that is being transformed and "
420
 
                      "the transform.",
421
 
                      (2, 5))
 
650
        hooks.Hooks.__init__(self)
 
651
        self.create_hook(hooks.HookPoint('start_commit',
 
652
            "Called before a commit is performed on a tree. The start commit "
 
653
            "hook is able to change the tree before the commit takes place. "
 
654
            "start_commit is called with the bzrlib.mutabletree.MutableTree "
 
655
            "that the commit is being performed on.", (1, 4), None))
 
656
        self.create_hook(hooks.HookPoint('post_commit',
 
657
            "Called after a commit is performed on a tree. The hook is "
 
658
            "called with a bzrlib.mutabletree.PostCommitHookParams object. "
 
659
            "The mutable tree the commit was performed on is available via "
 
660
            "the mutable_tree attribute of that object.", (2, 0), None))
422
661
 
423
662
 
424
663
# install the default hooks into the MutableTree class.
436
675
    def __init__(self, mutable_tree):
437
676
        """Create the parameters for the post_commit hook."""
438
677
        self.mutable_tree = mutable_tree
 
678
 
 
679
 
 
680
class _FastPath(object):
 
681
    """A path object with fast accessors for things like basename."""
 
682
 
 
683
    __slots__ = ['raw_path', 'base_path']
 
684
 
 
685
    def __init__(self, path, base_path=None):
 
686
        """Construct a FastPath from path."""
 
687
        if base_path is None:
 
688
            self.base_path = osutils.basename(path)
 
689
        else:
 
690
            self.base_path = base_path
 
691
        self.raw_path = path
 
692
 
 
693
    def __cmp__(self, other):
 
694
        return cmp(self.raw_path, other.raw_path)
 
695
 
 
696
    def __hash__(self):
 
697
        return hash(self.raw_path)
 
698
 
 
699
 
 
700
def _add_one_and_parent(tree, inv, parent_ie, path, kind, action):
 
701
    """Add a new entry to the inventory and automatically add unversioned parents.
 
702
 
 
703
    :param inv: Inventory which will receive the new entry.
 
704
    :param parent_ie: Parent inventory entry if known, or None.  If
 
705
        None, the parent is looked up by name and used if present, otherwise it
 
706
        is recursively added.
 
707
    :param kind: Kind of new entry (file, directory, etc)
 
708
    :param action: callback(inv, parent_ie, path, kind); return ignored.
 
709
    :return: A list of paths which have been added.
 
710
    """
 
711
    # Nothing to do if path is already versioned.
 
712
    # This is safe from infinite recursion because the tree root is
 
713
    # always versioned.
 
714
    if parent_ie is not None:
 
715
        # we have a parent ie already
 
716
        added = []
 
717
    else:
 
718
        # slower but does not need parent_ie
 
719
        if inv.has_filename(tree._fix_case_of_inventory_path(path.raw_path)):
 
720
            return []
 
721
        # its really not there : add the parent
 
722
        # note that the dirname use leads to some extra str copying etc but as
 
723
        # there are a limited number of dirs we can be nested under, it should
 
724
        # generally find it very fast and not recurse after that.
 
725
        added = _add_one_and_parent(tree, inv, None,
 
726
            _FastPath(osutils.dirname(path.raw_path)), 'directory', action)
 
727
        parent_id = inv.path2id(osutils.dirname(path.raw_path))
 
728
        parent_ie = inv[parent_id]
 
729
    _add_one(tree, inv, parent_ie, path, kind, action)
 
730
    return added + [path.raw_path]
 
731
 
 
732
 
 
733
def _add_one(tree, inv, parent_ie, path, kind, file_id_callback):
 
734
    """Add a new entry to the inventory.
 
735
 
 
736
    :param inv: Inventory which will receive the new entry.
 
737
    :param parent_ie: Parent inventory entry.
 
738
    :param kind: Kind of new entry (file, directory, etc)
 
739
    :param file_id_callback: callback(inv, parent_ie, path, kind); return a
 
740
        file_id or None to generate a new file id
 
741
    :returns: None
 
742
    """
 
743
    file_id = file_id_callback(inv, parent_ie, path, kind)
 
744
    entry = inv.make_entry(kind, path.base_path, parent_ie.file_id,
 
745
        file_id=file_id)
 
746
    inv.add(entry)