← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Aaron Bentley
  • Date: 2009-11-03 15:45:56 UTC
  • mto: (4634.97.2 2.0)
  • mto: This revision was merged to the branch mainline in revision 4798.
  • Revision ID: aaron@aaronbentley.com-20091103154556-e953dmegqbinyokq
Improve patch binary section handling.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/mutabletree.py
28
28
from bzrlib import (
29
29
    add,
30
30
    bzrdir,
 
31
    hooks,
 
32
    symbol_versioning,
 
33
    )
 
34
from bzrlib.osutils import dirname
 
35
from bzrlib.revisiontree import RevisionTree
 
36
from bzrlib.trace import mutter, warning
 
37
""")
 
38
 
 
39
from bzrlib import (
31
40
    errors,
32
 
    hooks,
33
41
    osutils,
34
 
    revisiontree,
35
 
    symbol_versioning,
36
 
    trace,
37
42
    tree,
38
43
    )
39
 
""")
40
 
 
41
44
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
45
from bzrlib.osutils import splitpath
42
46
 
43
47
 
44
48
def needs_tree_write_lock(unbound):
126
130
            # generic constraint checks:
127
131
            if self.is_control_filename(f):
128
132
                raise errors.ForbiddenControlFileError(filename=f)
129
 
            fp = osutils.splitpath(f)
 
133
            fp = splitpath(f)
130
134
        # fill out file kinds for all files [not needed when we stop
131
135
        # caring about the instantaneous file kind within a uncommmitted tree
132
136
        #
233
237
        raise NotImplementedError(self._gather_kinds)
234
238
 
235
239
    @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).
 
240
    def has_changes(self, from_tree):
 
241
        """Quickly check that the tree contains at least one change.
241
242
 
242
243
        :return: True if a change is found. False otherwise
243
244
        """
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)
 
245
        changes = self.iter_changes(from_tree)
250
246
        try:
251
247
            change = changes.next()
252
248
            # Exclude root (talk about black magic... --vila 20090629)
380
376
 
381
377
        if not file_list:
382
378
            # no paths supplied: add the entire tree.
383
 
            # FIXME: this assumes we are running in a working tree subdir :-/
384
 
            # -- vila 20100208
385
379
            file_list = [u'.']
386
380
        # mutter("smart add of %r")
387
381
        inv = self.inventory
389
383
        ignored = {}
390
384
        dirs_to_add = []
391
385
        user_dirs = set()
392
 
        conflicts_related = set()
393
 
        # Not all mutable trees can have conflicts
394
 
        if getattr(self, 'conflicts', None) is not None:
395
 
            # Collect all related files without checking whether they exist or
396
 
            # are versioned. It's cheaper to do that once for all conflicts
397
 
            # than trying to find the relevant conflict for each added file.
398
 
            for c in self.conflicts():
399
 
                conflicts_related.update(c.associated_filenames())
400
386
 
401
387
        # validate user file paths and convert all paths to tree
402
388
        # relative : it's cheaper to make a tree relative path an abspath
404
390
        # perform the canonicalization in bulk.
405
391
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
406
392
            rf = _FastPath(filepath)
407
 
            # validate user parameters. Our recursive code avoids adding new
408
 
            # files that need such validation
 
393
            # validate user parameters. Our recursive code avoids adding new files
 
394
            # that need such validation
409
395
            if self.is_control_filename(rf.raw_path):
410
396
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
411
397
 
417
403
            else:
418
404
                if not InventoryEntry.versionable_kind(kind):
419
405
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
420
 
            # ensure the named path is added, so that ignore rules in the later
421
 
            # directory walk dont skip it.
422
 
            # we dont have a parent ie known yet.: use the relatively slower
423
 
            # inventory probing method
 
406
            # ensure the named path is added, so that ignore rules in the later directory
 
407
            # walk dont skip it.
 
408
            # we dont have a parent ie known yet.: use the relatively slower inventory
 
409
            # probing method
424
410
            versioned = inv.has_filename(rf.raw_path)
425
411
            if versioned:
426
412
                continue
457
443
            kind = osutils.file_kind(abspath)
458
444
 
459
445
            if not InventoryEntry.versionable_kind(kind):
460
 
                trace.warning("skipping %s (can't add file of kind '%s')",
461
 
                              abspath, kind)
 
446
                warning("skipping %s (can't add file of kind '%s')", abspath, kind)
462
447
                continue
463
448
            if illegalpath_re.search(directory.raw_path):
464
 
                trace.warning("skipping %r (contains \\n or \\r)" % abspath)
465
 
                continue
466
 
            if directory.raw_path in conflicts_related:
467
 
                # If the file looks like one generated for a conflict, don't
468
 
                # add it.
469
 
                trace.warning(
470
 
                    'skipping %s (generated to help resolve conflicts)',
471
 
                    abspath)
 
449
                warning("skipping %r (contains \\n or \\r)" % abspath)
472
450
                continue
473
451
 
474
452
            if parent_ie is not None:
497
475
                pass
498
476
                # mutter("%r is already versioned", abspath)
499
477
            elif sub_tree:
500
 
                # XXX: This is wrong; people *might* reasonably be trying to
501
 
                # add subtrees as subtrees.  This should probably only be done
502
 
                # in formats which can represent subtrees, and even then
503
 
                # perhaps only when the user asked to add subtrees.  At the
504
 
                # moment you can add them specially through 'join --reference',
505
 
                # which is perhaps reasonable: adding a new reference is a
506
 
                # special operation and can have a special behaviour.  mbp
507
 
                # 20070306
508
 
                trace.mutter("%r is a nested bzr tree", abspath)
 
478
                # XXX: This is wrong; people *might* reasonably be trying to add
 
479
                # subtrees as subtrees.  This should probably only be done in formats
 
480
                # which can represent subtrees, and even then perhaps only when
 
481
                # the user asked to add subtrees.  At the moment you can add them
 
482
                # specially through 'join --reference', which is perhaps
 
483
                # reasonable: adding a new reference is a special operation and
 
484
                # can have a special behaviour.  mbp 20070306
 
485
                mutter("%r is a nested bzr tree", abspath)
509
486
            else:
510
487
                _add_one(self, inv, parent_ie, directory, kind, action)
511
488
                added.append(directory.raw_path)
518
495
                    # without the parent ie, use the relatively slower inventory
519
496
                    # probing method
520
497
                    this_id = inv.path2id(
521
 
                        self._fix_case_of_inventory_path(directory.raw_path))
 
498
                            self._fix_case_of_inventory_path(directory.raw_path))
522
499
                    if this_id is None:
523
500
                        this_ie = None
524
501
                    else:
533
510
                    # faster - its impossible for a non root dir to have a
534
511
                    # control file.
535
512
                    if self.is_control_filename(subp):
536
 
                        trace.mutter("skip control directory %r", subp)
 
513
                        mutter("skip control directory %r", subp)
537
514
                    elif subf in this_ie.children:
538
515
                        # recurse into this already versioned subdir.
539
516
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
595
572
        inventory = basis.inventory._get_mutable_inventory()
596
573
        basis.unlock()
597
574
        inventory.apply_delta(delta)
598
 
        rev_tree = revisiontree.RevisionTree(self.branch.repository,
599
 
                                             inventory, new_revid)
 
575
        rev_tree = RevisionTree(self.branch.repository, inventory, new_revid)
600
576
        self.set_parent_trees([(new_revid, rev_tree)])
601
577
 
602
578
 
685
661
        # there are a limited number of dirs we can be nested under, it should
686
662
        # generally find it very fast and not recurse after that.
687
663
        added = _add_one_and_parent(tree, inv, None,
688
 
            _FastPath(osutils.dirname(path.raw_path)), 'directory', action)
689
 
        parent_id = inv.path2id(osutils.dirname(path.raw_path))
 
664
            _FastPath(dirname(path.raw_path)), 'directory', action)
 
665
        parent_id = inv.path2id(dirname(path.raw_path))
690
666
        parent_ie = inv[parent_id]
691
667
    _add_one(tree, inv, parent_ie, path, kind, action)
692
668
    return added + [path.raw_path]