/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 breezy/mutabletree.py

  • Committer: Jelmer Vernooij
  • Date: 2020-02-18 01:57:45 UTC
  • mto: This revision was merged to the branch mainline in revision 7493.
  • Revision ID: jelmer@jelmer.uk-20200218015745-q2ss9tsk74h4nh61
drop use of future.

Show diffs side-by-side

added added

removed removed

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