/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: 2018-02-18 21:42:57 UTC
  • mto: This revision was merged to the branch mainline in revision 6859.
  • Revision ID: jelmer@jelmer.uk-20180218214257-jpevutp1wa30tz3v
Update TODO to reference Breezy, not Bazaar.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/mutabletree.py
19
19
See MutableTree for more details.
20
20
"""
21
21
 
 
22
from __future__ import absolute_import
 
23
 
22
24
from . import (
23
25
    errors,
24
26
    hooks,
27
29
    tree,
28
30
    )
29
31
 
 
32
from .sixish import (
 
33
    text_type,
 
34
    viewvalues,
 
35
    )
30
36
 
31
37
 
32
38
class BadReferenceTarget(errors.InternalBzrError):
58
64
    A mutable tree always has an associated Branch and ControlDir object - the
59
65
    branch and bzrdir attributes.
60
66
    """
61
 
 
62
67
    def __init__(self, *args, **kw):
63
68
        super(MutableTree, self).__init__(*args, **kw)
64
69
        # Is this tree on a case-insensitive or case-preserving file-system?
84
89
        Note that the command line normally calls smart_add instead,
85
90
        which can automatically recurse.
86
91
 
87
 
        This adds the files to the tree, so that they will be
 
92
        This adds the files to the inventory, so that they will be
88
93
        recorded by the next commit.
89
94
 
90
95
        :param files: List of paths to add, relative to the base of the tree.
96
101
 
97
102
        TODO: Perhaps callback with the ids and paths as they're added.
98
103
        """
99
 
        if isinstance(files, str):
 
104
        if isinstance(files, (str, text_type)):
100
105
            # XXX: Passing a single string is inconsistent and should be
101
106
            # deprecated.
102
 
            if not (ids is None or isinstance(ids, bytes)):
 
107
            if not (ids is None or isinstance(ids, (str, text_type))):
103
108
                raise AssertionError()
104
 
            if not (kinds is None or isinstance(kinds, str)):
 
109
            if not (kinds is None or isinstance(kinds, (str, text_type))):
105
110
                raise AssertionError()
106
111
            files = [files]
107
112
            if ids is not None:
152
157
    def commit(self, message=None, revprops=None, *args, **kwargs):
153
158
        # avoid circular imports
154
159
        from breezy import commit
155
 
        possible_master_transports = []
 
160
        possible_master_transports=[]
156
161
        with self.lock_write():
157
162
            revprops = commit.Commit.update_revprops(
158
 
                revprops,
159
 
                self.branch,
160
 
                kwargs.pop('authors', None),
161
 
                kwargs.get('local', False),
162
 
                possible_master_transports)
 
163
                    revprops,
 
164
                    self.branch,
 
165
                    kwargs.pop('authors', None),
 
166
                    kwargs.get('local', False),
 
167
                    possible_master_transports)
163
168
            # args for wt.commit start at message from the Commit.commit method,
164
169
            args = (message, ) + args
165
170
            for hook in MutableTree.hooks['start_commit']:
166
171
                hook(self)
167
172
            committed_id = commit.Commit().commit(working_tree=self,
168
 
                                                  revprops=revprops,
169
 
                                                  possible_master_transports=possible_master_transports,
170
 
                                                  *args, **kwargs)
 
173
                revprops=revprops,
 
174
                possible_master_transports=possible_master_transports,
 
175
                *args, **kwargs)
171
176
            post_hook_params = PostCommitHookParams(self)
172
177
            for hook in MutableTree.hooks['post_commit']:
173
178
                hook(post_hook_params)
192
197
            if _from_tree is None:
193
198
                _from_tree = self.basis_tree()
194
199
            changes = self.iter_changes(_from_tree)
195
 
            if self.supports_symlinks():
196
 
                # Fast path for has_changes.
197
 
                try:
 
200
            try:
 
201
                change = next(changes)
 
202
                # Exclude root (talk about black magic... --vila 20090629)
 
203
                if change[4] == (None, None):
198
204
                    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
205
                return True
 
206
            except StopIteration:
 
207
                # No changes
 
208
                return False
224
209
 
225
210
    def check_changed_or_out_of_date(self, strict, opt_name,
226
211
                                     more_error, more_warning):
304
289
        """
305
290
        raise NotImplementedError(self.mkdir)
306
291
 
307
 
    def _observed_sha1(self, path, sha_and_stat):
 
292
    def _observed_sha1(self, file_id, path, sha_and_stat):
308
293
        """Tell the tree we have observed a paths sha1.
309
294
 
310
295
        The intent of this function is to allow trees that have a hashcache to
314
299
 
315
300
        The default implementation does nothing.
316
301
 
 
302
        :param file_id: The file id
317
303
        :param path: The file path
318
304
        :param sha_and_stat: The sha 1 and stat result observed.
319
305
        :return: None
320
306
        """
321
307
 
322
 
    def put_file_bytes_non_atomic(self, path, bytes):
 
308
    def put_file_bytes_non_atomic(self, path, bytes, file_id=None):
323
309
        """Update the content of a file in the tree.
324
310
 
325
311
        Note that the file is written in-place rather than being
353
339
        This is designed more towards DWIM for humans than API clarity.
354
340
        For the specific behaviour see the help for cmd_add().
355
341
 
356
 
        :param file_list: List of zero or more paths.  *NB: these are
357
 
            interpreted relative to the process cwd, not relative to the
 
342
        :param file_list: List of zero or more paths.  *NB: these are 
 
343
            interpreted relative to the process cwd, not relative to the 
358
344
            tree.*  (Add and most other tree methods use tree-relative
359
345
            paths.)
360
 
        :param action: A reporter to be called with the working tree, parent_ie,
 
346
        :param action: A reporter to be called with the inventory, parent_ie,
361
347
            path and kind of the path being added. It may return a file_id if
362
348
            a specific one should be used.
363
 
        :param save: Save the changes after completing the adds. If False
 
349
        :param save: Save the inventory after completing the adds. If False
364
350
            this provides dry-run functionality by doing the add and not saving
365
 
            the changes.
 
351
            the inventory.
366
352
        :return: A tuple - files_added, ignored_files. files_added is the count
367
353
            of added files, and ignored_files is a dict mapping files that were
368
354
            ignored to the rule that caused them to be ignored.
401
387
        """
402
388
        raise NotImplementedError(self.copy_one)
403
389
 
404
 
    def transform(self, pb=None):
405
 
        """Return a transform object for use with this tree."""
406
 
        raise NotImplementedError(self.transform)
407
 
 
408
390
 
409
391
class MutableTreeHooks(hooks.Hooks):
410
392
    """A dictionary mapping a hook name to a list of callables for mutabletree
417
399
        """
418
400
        hooks.Hooks.__init__(self, "breezy.mutabletree", "MutableTree.hooks")
419
401
        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))
 
402
            "Called before a commit is performed on a tree. The start commit "
 
403
            "hook is able to change the tree before the commit takes place. "
 
404
            "start_commit is called with the breezy.mutabletree.MutableTree "
 
405
            "that the commit is being performed on.", (1, 4))
424
406
        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))
 
407
            "Called after a commit is performed on a tree. The hook is "
 
408
            "called with a breezy.mutabletree.PostCommitHookParams object. "
 
409
            "The mutable tree the commit was performed on is available via "
 
410
            "the mutable_tree attribute of that object.", (2, 0))
429
411
        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))
 
412
            "Called before a tree transform on this tree. The hook is called "
 
413
            "with the tree that is being transformed and the transform.",
 
414
            (2, 5))
433
415
        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))
 
416
            "Called after a completely new tree is built. The hook is "
 
417
            "called with the tree as its only argument.", (2, 5))
436
418
        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
 
 
 
419
            "Called after a tree transform has been performed on a tree. "
 
420
            "The hook is called with the tree that is being transformed and "
 
421
            "the transform.",
 
422
            (2, 5))
442
423
 
443
424
# install the default hooks into the MutableTree class.
444
425
MutableTree.hooks = MutableTreeHooks()