/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-11-16 18:26:22 UTC
  • mfrom: (7167.1.4 run-flake8)
  • Revision ID: breezy.the.bot@gmail.com-20181116182622-qw3gan3hz78a2imw
Add a flake8 test.

Merged from https://code.launchpad.net/~jelmer/brz/run-flake8/+merge/358902

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