/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: John Arbash Meinel
  • Date: 2011-04-22 14:12:22 UTC
  • mfrom: (5809 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5836.
  • Revision ID: john@arbash-meinel.com-20110422141222-nx2j0hbkihcb8j16
Merge newer bzr.dev and resolve conflicts.
Try to write some documentation about how the _dirblock_state works.
Fix up the tests so that they pass again.

Show diffs side-by-side

added added

removed removed

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