← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

Replace remaining to unittest.TestResult methods with super

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/mutabletree.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""MutableTree object.
18
18
 
23
23
from bzrlib.lazy_import import lazy_import
24
24
lazy_import(globals(), """
25
25
import os
 
26
import re
26
27
 
27
28
from bzrlib import (
28
29
    add,
29
30
    bzrdir,
 
31
    errors,
30
32
    hooks,
31
 
    )
32
 
from bzrlib.osutils import dirname
33
 
from bzrlib.revisiontree import RevisionTree
34
 
from bzrlib.trace import mutter, warning
35
 
""")
36
 
 
37
 
from bzrlib import (
38
 
    errors,
39
33
    osutils,
 
34
    revisiontree,
 
35
    symbol_versioning,
 
36
    trace,
40
37
    tree,
41
38
    )
 
39
""")
 
40
 
42
41
from bzrlib.decorators import needs_read_lock, needs_write_lock
43
 
from bzrlib.osutils import splitpath
44
 
from bzrlib.symbol_versioning import DEPRECATED_PARAMETER
45
42
 
46
43
 
47
44
def needs_tree_write_lock(unbound):
69
66
    entirely in memory.
70
67
 
71
68
    For now, we are not treating MutableTree as an interface to provide
72
 
    conformance tests for - rather we are testing MemoryTree specifically, and 
 
69
    conformance tests for - rather we are testing MemoryTree specifically, and
73
70
    interface testing implementations of WorkingTree.
74
71
 
75
72
    A mutable tree always has an associated Branch and BzrDir object - the
129
126
            # generic constraint checks:
130
127
            if self.is_control_filename(f):
131
128
                raise errors.ForbiddenControlFileError(filename=f)
132
 
            fp = splitpath(f)
133
 
        # fill out file kinds for all files [not needed when we stop 
 
129
            fp = osutils.splitpath(f)
 
130
        # fill out file kinds for all files [not needed when we stop
134
131
        # caring about the instantaneous file kind within a uncommmitted tree
135
132
        #
136
133
        self._gather_kinds(files, kinds)
185
182
               **kwargs):
186
183
        # avoid circular imports
187
184
        from bzrlib import commit
188
 
        if revprops is None:
189
 
            revprops = {}
190
185
        possible_master_transports=[]
191
 
        if not 'branch-nick' in revprops:
192
 
            revprops['branch-nick'] = self.branch._get_nick(
 
186
        revprops = commit.Commit.update_revprops(
 
187
                revprops,
 
188
                self.branch,
 
189
                kwargs.pop('authors', None),
 
190
                kwargs.pop('author', None),
193
191
                kwargs.get('local', False),
194
192
                possible_master_transports)
195
 
        author = kwargs.pop('author', None)
196
 
        if author is not None:
197
 
            if 'author' in revprops:
198
 
                # XXX: maybe we should just accept one of them?
199
 
                raise AssertionError('author property given twice')
200
 
            revprops['author'] = author
201
193
        # args for wt.commit start at message from the Commit.commit method,
202
194
        args = (message, ) + args
203
195
        for hook in MutableTree.hooks['start_commit']:
206
198
            revprops=revprops,
207
199
            possible_master_transports=possible_master_transports,
208
200
            *args, **kwargs)
 
201
        post_hook_params = PostCommitHookParams(self)
 
202
        for hook in MutableTree.hooks['post_commit']:
 
203
            hook(post_hook_params)
209
204
        return committed_id
210
205
 
211
206
    def _gather_kinds(self, files, kinds):
212
207
        """Helper function for add - sets the entries of kinds."""
213
208
        raise NotImplementedError(self._gather_kinds)
214
209
 
215
 
    def get_file_with_stat(self, file_id, path=None):
216
 
        """Get a file handle and stat object for file_id.
217
 
 
218
 
        The default implementation returns (self.get_file, None) for backwards
219
 
        compatibility.
220
 
 
221
 
        :param file_id: The file id to read.
222
 
        :param path: The path of the file, if it is known.
223
 
        :return: A tuple (file_handle, stat_value_or_None). If the tree has
224
 
            no stat facility, or need for a stat cache feedback during commit,
225
 
            it may return None for the second element of the tuple.
226
 
        """
227
 
        return (self.get_file(file_id, path), None)
 
210
    @needs_read_lock
 
211
    def has_changes(self, _from_tree=None):
 
212
        """Quickly check that the tree contains at least one commitable change.
 
213
 
 
214
        :param _from_tree: tree to compare against to find changes (default to
 
215
            the basis tree and is intended to be used by tests).
 
216
 
 
217
        :return: True if a change is found. False otherwise
 
218
        """
 
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
 
234
 
 
235
    @needs_read_lock
 
236
    def check_changed_or_out_of_date(self, strict, opt_name,
 
237
                                     more_error, more_warning):
 
238
        """Check the tree for uncommitted changes and branch synchronization.
 
239
 
 
240
        If strict is None and not set in the config files, a warning is issued.
 
241
        If strict is True, an error is raised.
 
242
        If strict is False, no checks are done and no warning is issued.
 
243
 
 
244
        :param strict: True, False or None, searched in branch config if None.
 
245
 
 
246
        :param opt_name: strict option name to search in config file.
 
247
 
 
248
        :param more_error: Details about how to avoid the check.
 
249
 
 
250
        :param more_warning: Details about what is happening.
 
251
        """
 
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
228
272
 
229
273
    @needs_read_lock
230
274
    def last_revision(self):
233
277
        In early tree formats the result of last_revision is the same as the
234
278
        branch last_revision, but that is no longer the case for modern tree
235
279
        formats.
236
 
        
 
280
 
237
281
        last_revision returns the left most parent id, or None if there are no
238
282
        parents.
239
283
 
256
300
    def lock_write(self):
257
301
        """Lock the tree and its branch. This allows mutating calls to be made.
258
302
 
259
 
        Some mutating methods will take out implicit write locks, but in 
 
303
        Some mutating methods will take out implicit write locks, but in
260
304
        general you should always obtain a write lock before calling mutating
261
305
        methods on a tree.
262
306
        """
278
322
        The intent of this function is to allow trees that have a hashcache to
279
323
        update the hashcache during commit. If the observed file is too new
280
324
        (based on the stat_value) to be safely hash-cached the tree will ignore
281
 
        it. 
 
325
        it.
282
326
 
283
327
        The default implementation does nothing.
284
328
 
298
342
    @needs_write_lock
299
343
    def put_file_bytes_non_atomic(self, file_id, bytes):
300
344
        """Update the content of a file in the tree.
301
 
        
 
345
 
302
346
        Note that the file is written in-place rather than being
303
347
        written to a temporary location and renamed. As a consequence,
304
348
        readers can potentially see the file half-written.
318
362
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
319
363
        """Set the parents of the working tree.
320
364
 
321
 
        :param parents_list: A list of (revision_id, tree) tuples. 
 
365
        :param parents_list: A list of (revision_id, tree) tuples.
322
366
            If tree is None, then that element is treated as an unreachable
323
367
            parent tree - i.e. a ghost.
324
368
        """
332
376
        For the specific behaviour see the help for cmd_add().
333
377
 
334
378
        :param action: A reporter to be called with the inventory, parent_ie,
335
 
            path and kind of the path being added. It may return a file_id if 
 
379
            path and kind of the path being added. It may return a file_id if
336
380
            a specific one should be used.
337
381
        :param save: Save the inventory after completing the adds. If False
338
382
            this provides dry-run functionality by doing the add and not saving
346
390
        from bzrlib.inventory import InventoryEntry
347
391
        if action is None:
348
392
            action = add.AddAction()
349
 
        
 
393
 
350
394
        if not file_list:
351
395
            # no paths supplied: add the entire tree.
 
396
            # FIXME: this assumes we are running in a working tree subdir :-/
 
397
            # -- vila 20100208
352
398
            file_list = [u'.']
353
399
        # mutter("smart add of %r")
354
400
        inv = self.inventory
356
402
        ignored = {}
357
403
        dirs_to_add = []
358
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())
359
413
 
360
 
        # validate user file paths and convert all paths to tree 
 
414
        # validate user file paths and convert all paths to tree
361
415
        # relative : it's cheaper to make a tree relative path an abspath
362
416
        # than to convert an abspath to tree relative, and it's cheaper to
363
417
        # perform the canonicalization in bulk.
364
418
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
365
419
            rf = _FastPath(filepath)
366
 
            # validate user parameters. Our recursive code avoids adding new files
367
 
            # that need such validation 
 
420
            # validate user parameters. Our recursive code avoids adding new
 
421
            # files that need such validation
368
422
            if self.is_control_filename(rf.raw_path):
369
423
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
370
 
            
 
424
 
371
425
            abspath = self.abspath(rf.raw_path)
372
426
            kind = osutils.file_kind(abspath)
373
427
            if kind == 'directory':
376
430
            else:
377
431
                if not InventoryEntry.versionable_kind(kind):
378
432
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
379
 
            # ensure the named path is added, so that ignore rules in the later directory
380
 
            # walk dont skip it.
381
 
            # we dont have a parent ie known yet.: use the relatively slower inventory 
382
 
            # probing method
 
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
383
437
            versioned = inv.has_filename(rf.raw_path)
384
438
            if versioned:
385
439
                continue
401
455
                dirs_to_add.append((path, None))
402
456
            prev_dir = path.raw_path
403
457
 
 
458
        illegalpath_re = re.compile(r'[\r\n]')
404
459
        # dirs_to_add is initialised to a list of directories, but as we scan
405
460
        # directories we append files to it.
406
461
        # XXX: We should determine kind of files when we scan them rather than
415
470
            kind = osutils.file_kind(abspath)
416
471
 
417
472
            if not InventoryEntry.versionable_kind(kind):
418
 
                warning("skipping %s (can't add file of kind '%s')", abspath, 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)
419
485
                continue
420
486
 
421
487
            if parent_ie is not None:
422
488
                versioned = directory.base_path in parent_ie.children
423
489
            else:
424
 
                # without the parent ie, use the relatively slower inventory 
 
490
                # without the parent ie, use the relatively slower inventory
425
491
                # probing method
426
492
                versioned = inv.has_filename(
427
493
                        self._fix_case_of_inventory_path(directory.raw_path))
444
510
                pass
445
511
                # mutter("%r is already versioned", abspath)
446
512
            elif sub_tree:
447
 
                # XXX: This is wrong; people *might* reasonably be trying to add
448
 
                # subtrees as subtrees.  This should probably only be done in formats 
449
 
                # which can represent subtrees, and even then perhaps only when
450
 
                # the user asked to add subtrees.  At the moment you can add them
451
 
                # specially through 'join --reference', which is perhaps
452
 
                # reasonable: adding a new reference is a special operation and
453
 
                # can have a special behaviour.  mbp 20070306
454
 
                mutter("%r is a nested bzr tree", abspath)
 
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)
455
522
            else:
456
523
                _add_one(self, inv, parent_ie, directory, kind, action)
457
524
                added.append(directory.raw_path)
461
528
                    # must be present:
462
529
                    this_ie = parent_ie.children[directory.base_path]
463
530
                else:
464
 
                    # without the parent ie, use the relatively slower inventory 
 
531
                    # without the parent ie, use the relatively slower inventory
465
532
                    # probing method
466
533
                    this_id = inv.path2id(
467
 
                            self._fix_case_of_inventory_path(directory.raw_path))
 
534
                        self._fix_case_of_inventory_path(directory.raw_path))
468
535
                    if this_id is None:
469
536
                        this_ie = None
470
537
                    else:
471
538
                        this_ie = inv[this_id]
472
539
 
473
540
                for subf in sorted(os.listdir(abspath)):
474
 
                    # here we could use TreeDirectory rather than 
 
541
                    # here we could use TreeDirectory rather than
475
542
                    # string concatenation.
476
543
                    subp = osutils.pathjoin(directory.raw_path, subf)
477
 
                    # TODO: is_control_filename is very slow. Make it faster. 
478
 
                    # TreeDirectory.is_control_filename could also make this 
479
 
                    # faster - its impossible for a non root dir to have a 
 
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
480
547
                    # control file.
481
548
                    if self.is_control_filename(subp):
482
 
                        mutter("skip control directory %r", subp)
 
549
                        trace.mutter("skip control directory %r", subp)
483
550
                    elif subf in this_ie.children:
484
551
                        # recurse into this already versioned subdir.
485
552
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
517
584
        for commit which is not required to handle situations that do not arise
518
585
        outside of commit.
519
586
 
 
587
        See the inventory developers documentation for the theory behind
 
588
        inventory deltas.
 
589
 
520
590
        :param new_revid: The new revision id for the trees parent.
521
591
        :param delta: An inventory delta (see apply_inventory_delta) describing
522
592
            the changes from the current left most parent revision to new_revid.
532
602
        # WorkingTree classes for optimised versions for specific format trees.
533
603
        basis = self.basis_tree()
534
604
        basis.lock_read()
535
 
        inventory = basis.inventory
 
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()
536
609
        basis.unlock()
537
610
        inventory.apply_delta(delta)
538
 
        rev_tree = RevisionTree(self.branch.repository, inventory, new_revid)
 
611
        rev_tree = revisiontree.RevisionTree(self.branch.repository,
 
612
                                             inventory, new_revid)
539
613
        self.set_parent_trees([(new_revid, rev_tree)])
540
614
 
541
615
 
542
616
class MutableTreeHooks(hooks.Hooks):
543
 
    """A dictionary mapping a hook name to a list of callables for mutabletree 
 
617
    """A dictionary mapping a hook name to a list of callables for mutabletree
544
618
    hooks.
545
619
    """
546
620
 
549
623
 
550
624
        """
551
625
        hooks.Hooks.__init__(self)
552
 
        # Invoked before a commit is done in a tree. New in 1.4
553
 
        self['start_commit'] = []
 
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))
554
636
 
555
637
 
556
638
# install the default hooks into the MutableTree class.
557
639
MutableTree.hooks = MutableTreeHooks()
558
640
 
559
641
 
 
642
class PostCommitHookParams(object):
 
643
    """Parameters for the post_commit hook.
 
644
 
 
645
    To access the parameters, use the following attributes:
 
646
 
 
647
    * mutable_tree - the MutableTree object
 
648
    """
 
649
 
 
650
    def __init__(self, mutable_tree):
 
651
        """Create the parameters for the post_commit hook."""
 
652
        self.mutable_tree = mutable_tree
 
653
 
 
654
 
560
655
class _FastPath(object):
561
656
    """A path object with fast accessors for things like basename."""
562
657
 
603
698
        # there are a limited number of dirs we can be nested under, it should
604
699
        # generally find it very fast and not recurse after that.
605
700
        added = _add_one_and_parent(tree, inv, None,
606
 
            _FastPath(dirname(path.raw_path)), 'directory', action)
607
 
        parent_id = inv.path2id(dirname(path.raw_path))
 
701
            _FastPath(osutils.dirname(path.raw_path)), 'directory', action)
 
702
        parent_id = inv.path2id(osutils.dirname(path.raw_path))
608
703
        parent_ie = inv[parent_id]
609
704
    _add_one(tree, inv, parent_ie, path, kind, action)
610
705
    return added + [path.raw_path]