/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 bzrlib/mutabletree.py

  • Committer: Vincent Ladeuil
  • Date: 2011-07-06 09:22:00 UTC
  • mfrom: (6008 +trunk)
  • mto: (6012.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6013.
  • Revision ID: v.ladeuil+lp@free.fr-20110706092200-7iai2mwzc0sqdsvf
Merging in trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/mutabletree.py
22
22
 
23
23
from bzrlib.lazy_import import lazy_import
24
24
lazy_import(globals(), """
 
25
import operator
25
26
import os
26
27
import re
27
28
 
28
29
from bzrlib import (
29
30
    add,
30
 
    bzrdir,
 
31
    controldir,
31
32
    errors,
32
33
    hooks,
 
34
    inventory as _mod_inventory,
33
35
    osutils,
34
36
    revisiontree,
35
 
    inventory,
36
 
    symbol_versioning,
37
37
    trace,
 
38
    transport as _mod_transport,
38
39
    tree,
39
40
    )
40
41
""")
80
81
        # used on media which doesn't differentiate the case of names.
81
82
        self.case_sensitive = True
82
83
 
 
84
    def is_control_filename(self, filename):
 
85
        """True if filename is the name of a control file in this tree.
 
86
 
 
87
        :param filename: A filename within the tree. This is a relative path
 
88
            from the root of this tree.
 
89
 
 
90
        This is true IF and ONLY IF the filename is part of the meta data
 
91
        that bzr controls in this tree. I.E. a random .bzr directory placed
 
92
        on disk will not be a control file for this tree.
 
93
        """
 
94
        raise NotImplementedError(self.is_control_filename)
 
95
 
83
96
    @needs_tree_write_lock
84
97
    def add(self, files, ids=None, kinds=None):
85
98
        """Add paths to the set of versioned paths.
149
162
        if sub_tree_id == self.get_root_id():
150
163
            raise errors.BadReferenceTarget(self, sub_tree,
151
164
                                     'Trees have the same root id.')
152
 
        if sub_tree_id in self.inventory:
 
165
        if self.has_id(sub_tree_id):
153
166
            raise errors.BadReferenceTarget(self, sub_tree,
154
167
                                            'Root id already present in tree')
155
168
        self._add([sub_tree_path], [sub_tree_id], ['tree-reference'])
164
177
        """
165
178
        raise NotImplementedError(self._add)
166
179
 
167
 
    @needs_tree_write_lock
168
180
    def apply_inventory_delta(self, changes):
169
181
        """Apply changes to the inventory as an atomic operation.
170
182
 
173
185
        :return None:
174
186
        :seealso Inventory.apply_delta: For details on the changes parameter.
175
187
        """
176
 
        self.flush()
177
 
        inv = self.inventory
178
 
        inv.apply_delta(changes)
179
 
        self._write_inventory(inv)
 
188
        raise NotImplementedError(self.apply_inventory_delta)
180
189
 
181
190
    @needs_write_lock
182
191
    def commit(self, message=None, revprops=None, *args,
334
343
        :return: None
335
344
        """
336
345
 
337
 
    def _fix_case_of_inventory_path(self, path):
338
 
        """If our tree isn't case sensitive, return the canonical path"""
339
 
        if not self.case_sensitive:
340
 
            path = self.get_canonical_inventory_path(path)
341
 
        return path
342
 
 
343
346
    @needs_write_lock
344
347
    def put_file_bytes_non_atomic(self, file_id, bytes):
345
348
        """Update the content of a file in the tree.
369
372
        """
370
373
        raise NotImplementedError(self.set_parent_trees)
371
374
 
372
 
    @needs_tree_write_lock
373
375
    def smart_add(self, file_list, recurse=True, action=None, save=True):
374
376
        """Version file_list, optionally recursing into directories.
375
377
 
390
392
            of added files, and ignored_files is a dict mapping files that were
391
393
            ignored to the rule that caused them to be ignored.
392
394
        """
393
 
        # not in an inner loop; and we want to remove direct use of this,
394
 
        # so here as a reminder for now. RBC 20070703
395
 
        from bzrlib.inventory import InventoryEntry
396
 
        if action is None:
397
 
            action = add.AddAction()
398
 
 
399
 
        if not file_list:
400
 
            # no paths supplied: add the entire tree.
401
 
            # FIXME: this assumes we are running in a working tree subdir :-/
402
 
            # -- vila 20100208
403
 
            file_list = [u'.']
404
 
        # mutter("smart add of %r")
 
395
        raise NotImplementedError(self.smart_add)
 
396
 
 
397
 
 
398
class MutableInventoryTree(MutableTree, tree.InventoryTree):
 
399
 
 
400
    @needs_tree_write_lock
 
401
    def apply_inventory_delta(self, changes):
 
402
        """Apply changes to the inventory as an atomic operation.
 
403
 
 
404
        :param changes: An inventory delta to apply to the working tree's
 
405
            inventory.
 
406
        :return None:
 
407
        :seealso Inventory.apply_delta: For details on the changes parameter.
 
408
        """
 
409
        self.flush()
405
410
        inv = self.inventory
406
 
        added = []
407
 
        ignored = {}
408
 
        dirs_to_add = []
409
 
        user_dirs = set()
410
 
        conflicts_related = set()
 
411
        inv.apply_delta(changes)
 
412
        self._write_inventory(inv)
 
413
 
 
414
    def _fix_case_of_inventory_path(self, path):
 
415
        """If our tree isn't case sensitive, return the canonical path"""
 
416
        if not self.case_sensitive:
 
417
            path = self.get_canonical_inventory_path(path)
 
418
        return path
 
419
 
 
420
    @needs_tree_write_lock
 
421
    def smart_add(self, file_list, recurse=True, action=None, save=True):
 
422
        """Version file_list, optionally recursing into directories.
 
423
 
 
424
        This is designed more towards DWIM for humans than API clarity.
 
425
        For the specific behaviour see the help for cmd_add().
 
426
 
 
427
        :param file_list: List of zero or more paths.  *NB: these are 
 
428
            interpreted relative to the process cwd, not relative to the 
 
429
            tree.*  (Add and most other tree methods use tree-relative
 
430
            paths.)
 
431
        :param action: A reporter to be called with the inventory, parent_ie,
 
432
            path and kind of the path being added. It may return a file_id if
 
433
            a specific one should be used.
 
434
        :param save: Save the inventory after completing the adds. If False
 
435
            this provides dry-run functionality by doing the add and not saving
 
436
            the inventory.
 
437
        :return: A tuple - files_added, ignored_files. files_added is the count
 
438
            of added files, and ignored_files is a dict mapping files that were
 
439
            ignored to the rule that caused them to be ignored.
 
440
        """
411
441
        # Not all mutable trees can have conflicts
412
442
        if getattr(self, 'conflicts', None) is not None:
413
443
            # Collect all related files without checking whether they exist or
414
444
            # are versioned. It's cheaper to do that once for all conflicts
415
445
            # than trying to find the relevant conflict for each added file.
 
446
            conflicts_related = set()
416
447
            for c in self.conflicts():
417
448
                conflicts_related.update(c.associated_filenames())
 
449
        else:
 
450
            conflicts_related = None
 
451
        adder = _SmartAddHelper(self, action, conflicts_related)
 
452
        adder.add(file_list, recurse=recurse)
 
453
        if save:
 
454
            invdelta = adder.get_inventory_delta()
 
455
            self.apply_inventory_delta(invdelta)
 
456
        return adder.added, adder.ignored
 
457
 
 
458
    def update_basis_by_delta(self, new_revid, delta):
 
459
        """Update the parents of this tree after a commit.
 
460
 
 
461
        This gives the tree one parent, with revision id new_revid. The
 
462
        inventory delta is applied to the current basis tree to generate the
 
463
        inventory for the parent new_revid, and all other parent trees are
 
464
        discarded.
 
465
 
 
466
        All the changes in the delta should be changes synchronising the basis
 
467
        tree with some or all of the working tree, with a change to a directory
 
468
        requiring that its contents have been recursively included. That is,
 
469
        this is not a general purpose tree modification routine, but a helper
 
470
        for commit which is not required to handle situations that do not arise
 
471
        outside of commit.
 
472
 
 
473
        See the inventory developers documentation for the theory behind
 
474
        inventory deltas.
 
475
 
 
476
        :param new_revid: The new revision id for the trees parent.
 
477
        :param delta: An inventory delta (see apply_inventory_delta) describing
 
478
            the changes from the current left most parent revision to new_revid.
 
479
        """
 
480
        # if the tree is updated by a pull to the branch, as happens in
 
481
        # WorkingTree2, when there was no separation between branch and tree,
 
482
        # then just clear merges, efficiency is not a concern for now as this
 
483
        # is legacy environments only, and they are slow regardless.
 
484
        if self.last_revision() == new_revid:
 
485
            self.set_parent_ids([new_revid])
 
486
            return
 
487
        # generic implementation based on Inventory manipulation. See
 
488
        # WorkingTree classes for optimised versions for specific format trees.
 
489
        basis = self.basis_tree()
 
490
        basis.lock_read()
 
491
        # TODO: Consider re-evaluating the need for this with CHKInventory
 
492
        # we don't strictly need to mutate an inventory for this
 
493
        # it only makes sense when apply_delta is cheaper than get_inventory()
 
494
        inventory = _mod_inventory.mutable_inventory_from_tree(basis)
 
495
        basis.unlock()
 
496
        inventory.apply_delta(delta)
 
497
        rev_tree = revisiontree.InventoryRevisionTree(self.branch.repository,
 
498
                                             inventory, new_revid)
 
499
        self.set_parent_trees([(new_revid, rev_tree)])
 
500
 
 
501
 
 
502
class MutableTreeHooks(hooks.Hooks):
 
503
    """A dictionary mapping a hook name to a list of callables for mutabletree
 
504
    hooks.
 
505
    """
 
506
 
 
507
    def __init__(self):
 
508
        """Create the default hooks.
 
509
 
 
510
        """
 
511
        hooks.Hooks.__init__(self, "bzrlib.mutabletree", "MutableTree.hooks")
 
512
        self.add_hook('start_commit',
 
513
            "Called before a commit is performed on a tree. The start commit "
 
514
            "hook is able to change the tree before the commit takes place. "
 
515
            "start_commit is called with the bzrlib.mutabletree.MutableTree "
 
516
            "that the commit is being performed on.", (1, 4))
 
517
        self.add_hook('post_commit',
 
518
            "Called after a commit is performed on a tree. The hook is "
 
519
            "called with a bzrlib.mutabletree.PostCommitHookParams object. "
 
520
            "The mutable tree the commit was performed on is available via "
 
521
            "the mutable_tree attribute of that object.", (2, 0))
 
522
 
 
523
 
 
524
# install the default hooks into the MutableTree class.
 
525
MutableTree.hooks = MutableTreeHooks()
 
526
 
 
527
 
 
528
class PostCommitHookParams(object):
 
529
    """Parameters for the post_commit hook.
 
530
 
 
531
    To access the parameters, use the following attributes:
 
532
 
 
533
    * mutable_tree - the MutableTree object
 
534
    """
 
535
 
 
536
    def __init__(self, mutable_tree):
 
537
        """Create the parameters for the post_commit hook."""
 
538
        self.mutable_tree = mutable_tree
 
539
 
 
540
 
 
541
class _SmartAddHelper(object):
 
542
    """Helper for MutableTree.smart_add."""
 
543
 
 
544
    def get_inventory_delta(self):
 
545
        return self._invdelta.values()
 
546
 
 
547
    def _get_ie(self, inv_path):
 
548
        """Retrieve the most up to date inventory entry for a path.
 
549
 
 
550
        :param inv_path: Normalized inventory path
 
551
        :return: Inventory entry (with possibly invalid .children for
 
552
            directories)
 
553
        """
 
554
        entry = self._invdelta.get(inv_path)
 
555
        if entry is not None:
 
556
            return entry[3]
 
557
        # Find a 'best fit' match if the filesystem is case-insensitive
 
558
        inv_path = self.tree._fix_case_of_inventory_path(inv_path)
 
559
        file_id = self.tree.path2id(inv_path)
 
560
        if file_id is not None:
 
561
            return self.tree.iter_entries_by_dir([file_id]).next()[1]
 
562
        return None
 
563
 
 
564
    def _convert_to_directory(self, this_ie, inv_path):
 
565
        """Convert an entry to a directory.
 
566
 
 
567
        :param this_ie: Inventory entry
 
568
        :param inv_path: Normalized path for the inventory entry
 
569
        :return: The new inventory entry
 
570
        """
 
571
        # Same as in _add_one below, if the inventory doesn't
 
572
        # think this is a directory, update the inventory
 
573
        this_ie = _mod_inventory.InventoryDirectory(
 
574
            this_ie.file_id, this_ie.name, this_ie.parent_id)
 
575
        self._invdelta[inv_path] = (inv_path, inv_path, this_ie.file_id,
 
576
            this_ie)
 
577
        return this_ie
 
578
 
 
579
    def _add_one_and_parent(self, parent_ie, path, kind, inv_path):
 
580
        """Add a new entry to the inventory and automatically add unversioned parents.
 
581
 
 
582
        :param parent_ie: Parent inventory entry if known, or None.  If
 
583
            None, the parent is looked up by name and used if present, otherwise it
 
584
            is recursively added.
 
585
        :param kind: Kind of new entry (file, directory, etc)
 
586
        :param action: callback(tree, parent_ie, path, kind); can return file_id
 
587
        :return: Inventory entry for path and a list of paths which have been added.
 
588
        """
 
589
        # Nothing to do if path is already versioned.
 
590
        # This is safe from infinite recursion because the tree root is
 
591
        # always versioned.
 
592
        inv_dirname = osutils.dirname(inv_path)
 
593
        dirname, basename = osutils.split(path)
 
594
        if parent_ie is None:
 
595
            # slower but does not need parent_ie
 
596
            this_ie = self._get_ie(inv_path)
 
597
            if this_ie is not None:
 
598
                return this_ie
 
599
            # its really not there : add the parent
 
600
            # note that the dirname use leads to some extra str copying etc but as
 
601
            # there are a limited number of dirs we can be nested under, it should
 
602
            # generally find it very fast and not recurse after that.
 
603
            parent_ie = self._add_one_and_parent(None,
 
604
                dirname, 'directory', 
 
605
                inv_dirname)
 
606
        # if the parent exists, but isn't a directory, we have to do the
 
607
        # kind change now -- really the inventory shouldn't pretend to know
 
608
        # the kind of wt files, but it does.
 
609
        if parent_ie.kind != 'directory':
 
610
            # nb: this relies on someone else checking that the path we're using
 
611
            # doesn't contain symlinks.
 
612
            parent_ie = self._convert_to_directory(parent_ie, inv_dirname)
 
613
        file_id = self.action(self.tree.inventory, parent_ie, path, kind)
 
614
        entry = _mod_inventory.make_entry(kind, basename, parent_ie.file_id,
 
615
            file_id=file_id)
 
616
        self._invdelta[inv_path] = (None, inv_path, entry.file_id, entry)
 
617
        self.added.append(inv_path)
 
618
        return entry
 
619
 
 
620
    def _gather_dirs_to_add(self, user_dirs):
 
621
        # only walk the minimal parents needed: we have user_dirs to override
 
622
        # ignores.
 
623
        prev_dir = None
 
624
 
 
625
        is_inside = osutils.is_inside_or_parent_of_any
 
626
        for path, (inv_path, this_ie) in sorted(
 
627
                user_dirs.iteritems(), key=operator.itemgetter(0)):
 
628
            if (prev_dir is None or not is_inside([prev_dir], path)):
 
629
                yield (path, inv_path, this_ie, None)
 
630
            prev_dir = path
 
631
 
 
632
    def __init__(self, tree, action, conflicts_related=None):
 
633
        self.tree = tree
 
634
        if action is None:
 
635
            self.action = add.AddAction()
 
636
        else:
 
637
            self.action = action
 
638
        self._invdelta = {}
 
639
        self.added = []
 
640
        self.ignored = {}
 
641
        if conflicts_related is None:
 
642
            self.conflicts_related = frozenset()
 
643
        else:
 
644
            self.conflicts_related = conflicts_related
 
645
 
 
646
    def add(self, file_list, recurse=True):
 
647
        from bzrlib.inventory import InventoryEntry
 
648
        if not file_list:
 
649
            # no paths supplied: add the entire tree.
 
650
            # FIXME: this assumes we are running in a working tree subdir :-/
 
651
            # -- vila 20100208
 
652
            file_list = [u'.']
418
653
 
419
654
        # expand any symlinks in the directory part, while leaving the
420
655
        # filename alone
422
657
        if osutils.has_symlinks():
423
658
            file_list = map(osutils.normalizepath, file_list)
424
659
 
 
660
        user_dirs = {}
425
661
        # validate user file paths and convert all paths to tree
426
662
        # relative : it's cheaper to make a tree relative path an abspath
427
663
        # than to convert an abspath to tree relative, and it's cheaper to
428
664
        # perform the canonicalization in bulk.
429
 
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
430
 
            rf = _FastPath(filepath)
 
665
        for filepath in osutils.canonical_relpaths(self.tree.basedir, file_list):
431
666
            # validate user parameters. Our recursive code avoids adding new
432
667
            # files that need such validation
433
 
            if self.is_control_filename(rf.raw_path):
434
 
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
 
668
            if self.tree.is_control_filename(filepath):
 
669
                raise errors.ForbiddenControlFileError(filename=filepath)
435
670
 
436
 
            abspath = self.abspath(rf.raw_path)
 
671
            abspath = self.tree.abspath(filepath)
437
672
            kind = osutils.file_kind(abspath)
438
 
            if kind == 'directory':
439
 
                # schedule the dir for scanning
440
 
                user_dirs.add(rf)
441
 
            else:
442
 
                if not InventoryEntry.versionable_kind(kind):
443
 
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
444
673
            # ensure the named path is added, so that ignore rules in the later
445
674
            # directory walk dont skip it.
446
675
            # we dont have a parent ie known yet.: use the relatively slower
447
676
            # inventory probing method
448
 
            versioned = inv.has_filename(rf.raw_path)
449
 
            if versioned:
450
 
                continue
451
 
            added.extend(_add_one_and_parent(self, inv, None, rf, kind, action))
 
677
            inv_path, _ = osutils.normalized_filename(filepath)
 
678
            this_ie = self._get_ie(inv_path)
 
679
            if this_ie is None:
 
680
                this_ie = self._add_one_and_parent(None, filepath, kind, inv_path)
 
681
            if kind == 'directory':
 
682
                # schedule the dir for scanning
 
683
                user_dirs[filepath] = (inv_path, this_ie)
452
684
 
453
685
        if not recurse:
454
686
            # no need to walk any directories at all.
455
 
            if len(added) > 0 and save:
456
 
                self._write_inventory(inv)
457
 
            return added, ignored
458
 
 
459
 
        # only walk the minimal parents needed: we have user_dirs to override
460
 
        # ignores.
461
 
        prev_dir = None
462
 
 
463
 
        is_inside = osutils.is_inside_or_parent_of_any
464
 
        for path in sorted(user_dirs):
465
 
            if (prev_dir is None or not is_inside([prev_dir], path.raw_path)):
466
 
                dirs_to_add.append((path, None))
467
 
            prev_dir = path.raw_path
 
687
            return
 
688
 
 
689
        things_to_add = list(self._gather_dirs_to_add(user_dirs))
468
690
 
469
691
        illegalpath_re = re.compile(r'[\r\n]')
470
 
        # dirs_to_add is initialised to a list of directories, but as we scan
471
 
        # directories we append files to it.
472
 
        # XXX: We should determine kind of files when we scan them rather than
473
 
        # adding to this list. RBC 20070703
474
 
        for directory, parent_ie in dirs_to_add:
 
692
        for directory, inv_path, this_ie, parent_ie in things_to_add:
475
693
            # directory is tree-relative
476
 
            abspath = self.abspath(directory.raw_path)
 
694
            abspath = self.tree.abspath(directory)
477
695
 
478
696
            # get the contents of this directory.
479
697
 
480
698
            # find the kind of the path being added.
481
 
            kind = osutils.file_kind(abspath)
 
699
            if this_ie is None:
 
700
                kind = osutils.file_kind(abspath)
 
701
            else:
 
702
                kind = this_ie.kind
482
703
 
483
704
            if not InventoryEntry.versionable_kind(kind):
484
705
                trace.warning("skipping %s (can't add file of kind '%s')",
485
706
                              abspath, kind)
486
707
                continue
487
 
            if illegalpath_re.search(directory.raw_path):
 
708
            if illegalpath_re.search(directory):
488
709
                trace.warning("skipping %r (contains \\n or \\r)" % abspath)
489
710
                continue
490
 
            if directory.raw_path in conflicts_related:
 
711
            if directory in self.conflicts_related:
491
712
                # If the file looks like one generated for a conflict, don't
492
713
                # add it.
493
714
                trace.warning(
495
716
                    abspath)
496
717
                continue
497
718
 
498
 
            if parent_ie is not None:
499
 
                versioned = directory.base_path in parent_ie.children
500
 
            else:
501
 
                # without the parent ie, use the relatively slower inventory
502
 
                # probing method
503
 
                versioned = inv.has_filename(
504
 
                        self._fix_case_of_inventory_path(directory.raw_path))
505
 
 
506
 
            if kind == 'directory':
 
719
            if kind == 'directory' and directory != '':
507
720
                try:
508
 
                    sub_branch = bzrdir.BzrDir.open(abspath)
 
721
                    transport = _mod_transport.get_transport(abspath)
 
722
                    controldir.ControlDirFormat.find_format(transport)
509
723
                    sub_tree = True
510
724
                except errors.NotBranchError:
511
725
                    sub_tree = False
514
728
            else:
515
729
                sub_tree = False
516
730
 
517
 
            if directory.raw_path == '':
518
 
                # mutter("tree root doesn't need to be added")
519
 
                sub_tree = False
520
 
            elif versioned:
 
731
            if this_ie is not None:
521
732
                pass
522
 
                # mutter("%r is already versioned", abspath)
523
733
            elif sub_tree:
524
734
                # XXX: This is wrong; people *might* reasonably be trying to
525
735
                # add subtrees as subtrees.  This should probably only be done
531
741
                # 20070306
532
742
                trace.mutter("%r is a nested bzr tree", abspath)
533
743
            else:
534
 
                _add_one(self, inv, parent_ie, directory, kind, action)
535
 
                added.append(directory.raw_path)
 
744
                this_ie = self._add_one_and_parent(parent_ie, directory, kind, inv_path)
536
745
 
537
746
            if kind == 'directory' and not sub_tree:
538
 
                if parent_ie is not None:
539
 
                    # must be present:
540
 
                    this_ie = parent_ie.children[directory.base_path]
541
 
                else:
542
 
                    # without the parent ie, use the relatively slower inventory
543
 
                    # probing method
544
 
                    this_id = inv.path2id(
545
 
                        self._fix_case_of_inventory_path(directory.raw_path))
546
 
                    if this_id is None:
547
 
                        this_ie = None
548
 
                    else:
549
 
                        this_ie = inv[this_id]
550
 
                        # Same as in _add_one below, if the inventory doesn't
551
 
                        # think this is a directory, update the inventory
552
 
                        if this_ie.kind != 'directory':
553
 
                            this_ie = inventory.make_entry('directory',
554
 
                                this_ie.name, this_ie.parent_id, this_id)
555
 
                            del inv[this_id]
556
 
                            inv.add(this_ie)
 
747
                if this_ie.kind != 'directory':
 
748
                    this_ie = self._convert_to_directory(this_ie, inv_path)
557
749
 
558
750
                for subf in sorted(os.listdir(abspath)):
 
751
                    inv_f, _ = osutils.normalized_filename(subf)
559
752
                    # here we could use TreeDirectory rather than
560
753
                    # string concatenation.
561
 
                    subp = osutils.pathjoin(directory.raw_path, subf)
 
754
                    subp = osutils.pathjoin(directory, subf)
562
755
                    # TODO: is_control_filename is very slow. Make it faster.
563
756
                    # TreeDirectory.is_control_filename could also make this
564
757
                    # faster - its impossible for a non root dir to have a
565
758
                    # control file.
566
 
                    if self.is_control_filename(subp):
 
759
                    if self.tree.is_control_filename(subp):
567
760
                        trace.mutter("skip control directory %r", subp)
568
 
                    elif subf in this_ie.children:
 
761
                        continue
 
762
                    sub_invp = osutils.pathjoin(inv_path, inv_f)
 
763
                    entry = self._invdelta.get(sub_invp)
 
764
                    if entry is not None:
 
765
                        sub_ie = entry[3]
 
766
                    else:
 
767
                        sub_ie = this_ie.children.get(inv_f)
 
768
                    if sub_ie is not None:
569
769
                        # recurse into this already versioned subdir.
570
 
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
 
770
                        things_to_add.append((subp, sub_invp, sub_ie, this_ie))
571
771
                    else:
572
772
                        # user selection overrides ignoes
573
773
                        # ignore while selecting files - if we globbed in the
574
774
                        # outer loop we would ignore user files.
575
 
                        ignore_glob = self.is_ignored(subp)
 
775
                        ignore_glob = self.tree.is_ignored(subp)
576
776
                        if ignore_glob is not None:
577
 
                            # mutter("skip ignored sub-file %r", subp)
578
 
                            ignored.setdefault(ignore_glob, []).append(subp)
 
777
                            self.ignored.setdefault(ignore_glob, []).append(subp)
579
778
                        else:
580
 
                            #mutter("queue to add sub-file %r", subp)
581
 
                            dirs_to_add.append((_FastPath(subp, subf), this_ie))
582
 
 
583
 
        if len(added) > 0:
584
 
            if save:
585
 
                self._write_inventory(inv)
586
 
            else:
587
 
                self.read_working_inventory()
588
 
        return added, ignored
589
 
 
590
 
    def update_basis_by_delta(self, new_revid, delta):
591
 
        """Update the parents of this tree after a commit.
592
 
 
593
 
        This gives the tree one parent, with revision id new_revid. The
594
 
        inventory delta is applied to the current basis tree to generate the
595
 
        inventory for the parent new_revid, and all other parent trees are
596
 
        discarded.
597
 
 
598
 
        All the changes in the delta should be changes synchronising the basis
599
 
        tree with some or all of the working tree, with a change to a directory
600
 
        requiring that its contents have been recursively included. That is,
601
 
        this is not a general purpose tree modification routine, but a helper
602
 
        for commit which is not required to handle situations that do not arise
603
 
        outside of commit.
604
 
 
605
 
        See the inventory developers documentation for the theory behind
606
 
        inventory deltas.
607
 
 
608
 
        :param new_revid: The new revision id for the trees parent.
609
 
        :param delta: An inventory delta (see apply_inventory_delta) describing
610
 
            the changes from the current left most parent revision to new_revid.
611
 
        """
612
 
        # if the tree is updated by a pull to the branch, as happens in
613
 
        # WorkingTree2, when there was no separation between branch and tree,
614
 
        # then just clear merges, efficiency is not a concern for now as this
615
 
        # is legacy environments only, and they are slow regardless.
616
 
        if self.last_revision() == new_revid:
617
 
            self.set_parent_ids([new_revid])
618
 
            return
619
 
        # generic implementation based on Inventory manipulation. See
620
 
        # WorkingTree classes for optimised versions for specific format trees.
621
 
        basis = self.basis_tree()
622
 
        basis.lock_read()
623
 
        # TODO: Consider re-evaluating the need for this with CHKInventory
624
 
        # we don't strictly need to mutate an inventory for this
625
 
        # it only makes sense when apply_delta is cheaper than get_inventory()
626
 
        inventory = basis.inventory._get_mutable_inventory()
627
 
        basis.unlock()
628
 
        inventory.apply_delta(delta)
629
 
        rev_tree = revisiontree.RevisionTree(self.branch.repository,
630
 
                                             inventory, new_revid)
631
 
        self.set_parent_trees([(new_revid, rev_tree)])
632
 
 
633
 
 
634
 
class MutableTreeHooks(hooks.Hooks):
635
 
    """A dictionary mapping a hook name to a list of callables for mutabletree
636
 
    hooks.
637
 
    """
638
 
 
639
 
    def __init__(self):
640
 
        """Create the default hooks.
641
 
 
642
 
        """
643
 
        hooks.Hooks.__init__(self)
644
 
        self.create_hook(hooks.HookPoint('start_commit',
645
 
            "Called before a commit is performed on a tree. The start commit "
646
 
            "hook is able to change the tree before the commit takes place. "
647
 
            "start_commit is called with the bzrlib.mutabletree.MutableTree "
648
 
            "that the commit is being performed on.", (1, 4), None))
649
 
        self.create_hook(hooks.HookPoint('post_commit',
650
 
            "Called after a commit is performed on a tree. The hook is "
651
 
            "called with a bzrlib.mutabletree.PostCommitHookParams object. "
652
 
            "The mutable tree the commit was performed on is available via "
653
 
            "the mutable_tree attribute of that object.", (2, 0), None))
654
 
 
655
 
 
656
 
# install the default hooks into the MutableTree class.
657
 
MutableTree.hooks = MutableTreeHooks()
658
 
 
659
 
 
660
 
class PostCommitHookParams(object):
661
 
    """Parameters for the post_commit hook.
662
 
 
663
 
    To access the parameters, use the following attributes:
664
 
 
665
 
    * mutable_tree - the MutableTree object
666
 
    """
667
 
 
668
 
    def __init__(self, mutable_tree):
669
 
        """Create the parameters for the post_commit hook."""
670
 
        self.mutable_tree = mutable_tree
671
 
 
672
 
 
673
 
class _FastPath(object):
674
 
    """A path object with fast accessors for things like basename."""
675
 
 
676
 
    __slots__ = ['raw_path', 'base_path']
677
 
 
678
 
    def __init__(self, path, base_path=None):
679
 
        """Construct a FastPath from path."""
680
 
        if base_path is None:
681
 
            self.base_path = osutils.basename(path)
682
 
        else:
683
 
            self.base_path = base_path
684
 
        self.raw_path = path
685
 
 
686
 
    def __cmp__(self, other):
687
 
        return cmp(self.raw_path, other.raw_path)
688
 
 
689
 
    def __hash__(self):
690
 
        return hash(self.raw_path)
691
 
 
692
 
 
693
 
def _add_one_and_parent(tree, inv, parent_ie, path, kind, action):
694
 
    """Add a new entry to the inventory and automatically add unversioned parents.
695
 
 
696
 
    :param inv: Inventory which will receive the new entry.
697
 
    :param parent_ie: Parent inventory entry if known, or None.  If
698
 
        None, the parent is looked up by name and used if present, otherwise it
699
 
        is recursively added.
700
 
    :param kind: Kind of new entry (file, directory, etc)
701
 
    :param action: callback(inv, parent_ie, path, kind); return ignored.
702
 
    :return: A list of paths which have been added.
703
 
    """
704
 
    # Nothing to do if path is already versioned.
705
 
    # This is safe from infinite recursion because the tree root is
706
 
    # always versioned.
707
 
    if parent_ie is not None:
708
 
        # we have a parent ie already
709
 
        added = []
710
 
    else:
711
 
        # slower but does not need parent_ie
712
 
        if inv.has_filename(tree._fix_case_of_inventory_path(path.raw_path)):
713
 
            return []
714
 
        # its really not there : add the parent
715
 
        # note that the dirname use leads to some extra str copying etc but as
716
 
        # there are a limited number of dirs we can be nested under, it should
717
 
        # generally find it very fast and not recurse after that.
718
 
        added = _add_one_and_parent(tree, inv, None,
719
 
            _FastPath(osutils.dirname(path.raw_path)), 'directory', action)
720
 
        parent_id = inv.path2id(osutils.dirname(path.raw_path))
721
 
        parent_ie = inv[parent_id]
722
 
    _add_one(tree, inv, parent_ie, path, kind, action)
723
 
    return added + [path.raw_path]
724
 
 
725
 
 
726
 
def _add_one(tree, inv, parent_ie, path, kind, file_id_callback):
727
 
    """Add a new entry to the inventory.
728
 
 
729
 
    :param inv: Inventory which will receive the new entry.
730
 
    :param parent_ie: Parent inventory entry.
731
 
    :param kind: Kind of new entry (file, directory, etc)
732
 
    :param file_id_callback: callback(inv, parent_ie, path, kind); return a
733
 
        file_id or None to generate a new file id
734
 
    :returns: None
735
 
    """
736
 
    # if the parent exists, but isn't a directory, we have to do the
737
 
    # kind change now -- really the inventory shouldn't pretend to know
738
 
    # the kind of wt files, but it does.
739
 
    if parent_ie.kind != 'directory':
740
 
        # nb: this relies on someone else checking that the path we're using
741
 
        # doesn't contain symlinks.
742
 
        new_parent_ie = inventory.make_entry('directory', parent_ie.name,
743
 
            parent_ie.parent_id, parent_ie.file_id)
744
 
        del inv[parent_ie.file_id]
745
 
        inv.add(new_parent_ie)
746
 
        parent_ie = new_parent_ie
747
 
    file_id = file_id_callback(inv, parent_ie, path, kind)
748
 
    entry = inv.make_entry(kind, path.base_path, parent_ie.file_id,
749
 
        file_id=file_id)
750
 
    inv.add(entry)
 
779
                            things_to_add.append((subp, sub_invp, None, this_ie))