← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Vincent Ladeuil
  • Date: 2010-04-26 13:51:08 UTC
  • mto: (5184.2.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5185.
  • Revision ID: v.ladeuil+lp@free.fr-20100426135108-vwmfphc2xg1w058c
Random cleanups to catch up with copyright updates in trunk.

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
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,
 
33
    osutils,
 
34
    revisiontree,
31
35
    symbol_versioning,
 
36
    trace,
 
37
    tree,
32
38
    )
33
 
from bzrlib.osutils import dirname
34
 
from bzrlib.revisiontree import RevisionTree
35
 
from bzrlib.trace import mutter, warning
36
39
""")
37
40
 
38
 
from bzrlib import (
39
 
    errors,
40
 
    osutils,
41
 
    tree,
42
 
    )
43
41
from bzrlib.decorators import needs_read_lock, needs_write_lock
44
 
from bzrlib.osutils import splitpath
45
42
 
46
43
 
47
44
def needs_tree_write_lock(unbound):
129
126
            # generic constraint checks:
130
127
            if self.is_control_filename(f):
131
128
                raise errors.ForbiddenControlFileError(filename=f)
132
 
            fp = splitpath(f)
 
129
            fp = osutils.splitpath(f)
133
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
        #
226
223
            revprops=revprops,
227
224
            possible_master_transports=possible_master_transports,
228
225
            *args, **kwargs)
 
226
        post_hook_params = PostCommitHookParams(self)
 
227
        for hook in MutableTree.hooks['post_commit']:
 
228
            hook(post_hook_params)
229
229
        return committed_id
230
230
 
231
231
    def _gather_kinds(self, files, kinds):
232
232
        """Helper function for add - sets the entries of kinds."""
233
233
        raise NotImplementedError(self._gather_kinds)
234
234
 
235
 
    def get_file_with_stat(self, file_id, path=None):
236
 
        """Get a file handle and stat object for file_id.
237
 
 
238
 
        The default implementation returns (self.get_file, None) for backwards
239
 
        compatibility.
240
 
 
241
 
        :param file_id: The file id to read.
242
 
        :param path: The path of the file, if it is known.
243
 
        :return: A tuple (file_handle, stat_value_or_None). If the tree has
244
 
            no stat facility, or need for a stat cache feedback during commit,
245
 
            it may return None for the second element of the tuple.
246
 
        """
247
 
        return (self.get_file(file_id, path), None)
 
235
    @needs_read_lock
 
236
    def has_changes(self, _from_tree=None):
 
237
        """Quickly check that the tree contains at least one commitable change.
 
238
 
 
239
        :param _from_tree: tree to compare against to find changes (default to
 
240
            the basis tree and is intended to be used by tests).
 
241
 
 
242
        :return: True if a change is found. False otherwise
 
243
        """
 
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
 
259
 
 
260
    @needs_read_lock
 
261
    def warn_if_changed_or_out_of_date(self, strict, opt_name, more_msg):
 
262
        """Check the tree for uncommitted changes and branch synchronization.
 
263
 
 
264
        If strict is None and not set in the config files, a warning is issued.
 
265
        If strict is True, an error is raised.
 
266
        If strict is False, no checks are done and no warning is issued.
 
267
 
 
268
        :param strict: True, False or None, searched in branch config if None.
 
269
 
 
270
        :param opt_name: strict option name to search in config file.
 
271
 
 
272
        :param more_msg: Details about how to avoid the warnings.
 
273
        """
 
274
        if strict is None:
 
275
            strict = self.branch.get_config().get_user_option_as_bool(opt_name)
 
276
        if strict is not False:
 
277
            err = None
 
278
            if (self.has_changes()):
 
279
                err = errors.UncommittedChanges(self, more=more_msg)
 
280
            elif self.last_revision() != self.branch.last_revision():
 
281
                # The tree has lost sync with its branch, there is little
 
282
                # chance that the user is aware of it but he can still force
 
283
                # the action with --no-strict
 
284
                err = errors.OutOfDateTree(self, more=more_msg)
 
285
            if err is not None:
 
286
                if strict is None:
 
287
                    # We don't want to interrupt the user if he expressed no
 
288
                    # preference about strict.
 
289
                    trace.warning('%s', err._format())
 
290
                else:
 
291
                    raise err
248
292
 
249
293
    @needs_read_lock
250
294
    def last_revision(self):
369
413
 
370
414
        if not file_list:
371
415
            # no paths supplied: add the entire tree.
 
416
            # FIXME: this assumes we are running in a working tree subdir :-/
 
417
            # -- vila 20100208
372
418
            file_list = [u'.']
373
419
        # mutter("smart add of %r")
374
420
        inv = self.inventory
376
422
        ignored = {}
377
423
        dirs_to_add = []
378
424
        user_dirs = set()
 
425
        conflicts_related = set()
 
426
        # Not all mutable trees can have conflicts
 
427
        if getattr(self, 'conflicts', None) is not None:
 
428
            # Collect all related files without checking whether they exist or
 
429
            # are versioned. It's cheaper to do that once for all conflicts
 
430
            # than trying to find the relevant conflict for each added file.
 
431
            for c in self.conflicts():
 
432
                conflicts_related.update(c.associated_filenames())
379
433
 
380
434
        # validate user file paths and convert all paths to tree
381
435
        # relative : it's cheaper to make a tree relative path an abspath
383
437
        # perform the canonicalization in bulk.
384
438
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
385
439
            rf = _FastPath(filepath)
386
 
            # validate user parameters. Our recursive code avoids adding new files
387
 
            # that need such validation
 
440
            # validate user parameters. Our recursive code avoids adding new
 
441
            # files that need such validation
388
442
            if self.is_control_filename(rf.raw_path):
389
443
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
390
444
 
396
450
            else:
397
451
                if not InventoryEntry.versionable_kind(kind):
398
452
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
399
 
            # ensure the named path is added, so that ignore rules in the later directory
400
 
            # walk dont skip it.
401
 
            # we dont have a parent ie known yet.: use the relatively slower inventory
402
 
            # probing method
 
453
            # ensure the named path is added, so that ignore rules in the later
 
454
            # directory walk dont skip it.
 
455
            # we dont have a parent ie known yet.: use the relatively slower
 
456
            # inventory probing method
403
457
            versioned = inv.has_filename(rf.raw_path)
404
458
            if versioned:
405
459
                continue
421
475
                dirs_to_add.append((path, None))
422
476
            prev_dir = path.raw_path
423
477
 
 
478
        illegalpath_re = re.compile(r'[\r\n]')
424
479
        # dirs_to_add is initialised to a list of directories, but as we scan
425
480
        # directories we append files to it.
426
481
        # XXX: We should determine kind of files when we scan them rather than
435
490
            kind = osutils.file_kind(abspath)
436
491
 
437
492
            if not InventoryEntry.versionable_kind(kind):
438
 
                warning("skipping %s (can't add file of kind '%s')", abspath, kind)
 
493
                trace.warning("skipping %s (can't add file of kind '%s')",
 
494
                              abspath, kind)
 
495
                continue
 
496
            if illegalpath_re.search(directory.raw_path):
 
497
                trace.warning("skipping %r (contains \\n or \\r)" % abspath)
 
498
                continue
 
499
            if directory.raw_path in conflicts_related:
 
500
                # If the file looks like one generated for a conflict, don't
 
501
                # add it.
 
502
                trace.warning(
 
503
                    'skipping %s (generated to help resolve conflicts)',
 
504
                    abspath)
439
505
                continue
440
506
 
441
507
            if parent_ie is not None:
464
530
                pass
465
531
                # mutter("%r is already versioned", abspath)
466
532
            elif sub_tree:
467
 
                # XXX: This is wrong; people *might* reasonably be trying to add
468
 
                # subtrees as subtrees.  This should probably only be done in formats
469
 
                # which can represent subtrees, and even then perhaps only when
470
 
                # the user asked to add subtrees.  At the moment you can add them
471
 
                # specially through 'join --reference', which is perhaps
472
 
                # reasonable: adding a new reference is a special operation and
473
 
                # can have a special behaviour.  mbp 20070306
474
 
                mutter("%r is a nested bzr tree", abspath)
 
533
                # XXX: This is wrong; people *might* reasonably be trying to
 
534
                # add subtrees as subtrees.  This should probably only be done
 
535
                # in formats which can represent subtrees, and even then
 
536
                # perhaps only when the user asked to add subtrees.  At the
 
537
                # moment you can add them specially through 'join --reference',
 
538
                # which is perhaps reasonable: adding a new reference is a
 
539
                # special operation and can have a special behaviour.  mbp
 
540
                # 20070306
 
541
                trace.mutter("%r is a nested bzr tree", abspath)
475
542
            else:
476
543
                _add_one(self, inv, parent_ie, directory, kind, action)
477
544
                added.append(directory.raw_path)
484
551
                    # without the parent ie, use the relatively slower inventory
485
552
                    # probing method
486
553
                    this_id = inv.path2id(
487
 
                            self._fix_case_of_inventory_path(directory.raw_path))
 
554
                        self._fix_case_of_inventory_path(directory.raw_path))
488
555
                    if this_id is None:
489
556
                        this_ie = None
490
557
                    else:
499
566
                    # faster - its impossible for a non root dir to have a
500
567
                    # control file.
501
568
                    if self.is_control_filename(subp):
502
 
                        mutter("skip control directory %r", subp)
 
569
                        trace.mutter("skip control directory %r", subp)
503
570
                    elif subf in this_ie.children:
504
571
                        # recurse into this already versioned subdir.
505
572
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
537
604
        for commit which is not required to handle situations that do not arise
538
605
        outside of commit.
539
606
 
 
607
        See the inventory developers documentation for the theory behind
 
608
        inventory deltas.
 
609
 
540
610
        :param new_revid: The new revision id for the trees parent.
541
611
        :param delta: An inventory delta (see apply_inventory_delta) describing
542
612
            the changes from the current left most parent revision to new_revid.
558
628
        inventory = basis.inventory._get_mutable_inventory()
559
629
        basis.unlock()
560
630
        inventory.apply_delta(delta)
561
 
        rev_tree = RevisionTree(self.branch.repository, inventory, new_revid)
 
631
        rev_tree = revisiontree.RevisionTree(self.branch.repository,
 
632
                                             inventory, new_revid)
562
633
        self.set_parent_trees([(new_revid, rev_tree)])
563
634
 
564
635
 
575
646
        self.create_hook(hooks.HookPoint('start_commit',
576
647
            "Called before a commit is performed on a tree. The start commit "
577
648
            "hook is able to change the tree before the commit takes place. "
578
 
            "start_commit is called with the bzrlib.tree.MutableTree that the "
579
 
            "commit is being performed on.", (1, 4), None))
 
649
            "start_commit is called with the bzrlib.mutabletree.MutableTree "
 
650
            "that the commit is being performed on.", (1, 4), None))
 
651
        self.create_hook(hooks.HookPoint('post_commit',
 
652
            "Called after a commit is performed on a tree. The hook is "
 
653
            "called with a bzrlib.mutabletree.PostCommitHookParams object. "
 
654
            "The mutable tree the commit was performed on is available via "
 
655
            "the mutable_tree attribute of that object.", (2, 0), None))
580
656
 
581
657
 
582
658
# install the default hooks into the MutableTree class.
583
659
MutableTree.hooks = MutableTreeHooks()
584
660
 
585
661
 
 
662
class PostCommitHookParams(object):
 
663
    """Parameters for the post_commit hook.
 
664
 
 
665
    To access the parameters, use the following attributes:
 
666
 
 
667
    * mutable_tree - the MutableTree object
 
668
    """
 
669
 
 
670
    def __init__(self, mutable_tree):
 
671
        """Create the parameters for the post_commit hook."""
 
672
        self.mutable_tree = mutable_tree
 
673
 
 
674
 
586
675
class _FastPath(object):
587
676
    """A path object with fast accessors for things like basename."""
588
677
 
629
718
        # there are a limited number of dirs we can be nested under, it should
630
719
        # generally find it very fast and not recurse after that.
631
720
        added = _add_one_and_parent(tree, inv, None,
632
 
            _FastPath(dirname(path.raw_path)), 'directory', action)
633
 
        parent_id = inv.path2id(dirname(path.raw_path))
 
721
            _FastPath(osutils.dirname(path.raw_path)), 'directory', action)
 
722
        parent_id = inv.path2id(osutils.dirname(path.raw_path))
634
723
        parent_ie = inv[parent_id]
635
724
    _add_one(tree, inv, parent_ie, path, kind, action)
636
725
    return added + [path.raw_path]