/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: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

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