/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/merge.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
16
16
 
17
17
import warnings
18
18
 
19
 
from bzrlib.lazy_import import lazy_import
20
 
lazy_import(globals(), """
21
19
from bzrlib import (
22
20
    branch as _mod_branch,
23
 
    cleanup,
24
21
    conflicts as _mod_conflicts,
25
22
    debug,
26
 
    generate_ids,
 
23
    decorators,
 
24
    errors,
27
25
    graph as _mod_graph,
 
26
    hooks,
28
27
    merge3,
29
28
    osutils,
30
29
    patiencediff,
35
34
    tree as _mod_tree,
36
35
    tsort,
37
36
    ui,
38
 
    versionedfile,
39
 
    workingtree,
40
 
    )
41
 
""")
42
 
from bzrlib import (
43
 
    decorators,
44
 
    errors,
45
 
    hooks,
46
 
    )
 
37
    versionedfile
 
38
    )
 
39
from bzrlib.cleanup import OperationWithCleanups
47
40
from bzrlib.symbol_versioning import (
48
41
    deprecated_in,
49
42
    deprecated_method,
53
46
 
54
47
def transform_tree(from_tree, to_tree, interesting_ids=None):
55
48
    from_tree.lock_tree_write()
56
 
    operation = cleanup.OperationWithCleanups(merge_inner)
 
49
    operation = OperationWithCleanups(merge_inner)
57
50
    operation.add_cleanup(from_tree.unlock)
58
51
    operation.run_simple(from_tree.branch, to_tree, from_tree,
59
52
        ignore_zero=True, interesting_ids=interesting_ids, this_tree=from_tree)
62
55
class MergeHooks(hooks.Hooks):
63
56
 
64
57
    def __init__(self):
65
 
        hooks.Hooks.__init__(self, "bzrlib.merge", "Merger.hooks")
66
 
        self.add_hook('merge_file_content',
 
58
        hooks.Hooks.__init__(self)
 
59
        self.create_hook(hooks.HookPoint('merge_file_content',
67
60
            "Called with a bzrlib.merge.Merger object to create a per file "
68
61
            "merge object when starting a merge. "
69
62
            "Should return either None or a subclass of "
73
66
            "side has deleted the file and the other has changed it). "
74
67
            "See the AbstractPerFileMerger API docs for details on how it is "
75
68
            "used by merge.",
76
 
            (2, 1))
 
69
            (2, 1), None))
77
70
 
78
71
 
79
72
class AbstractPerFileMerger(object):
428
421
        return self._cached_trees[revision_id]
429
422
 
430
423
    def _get_tree(self, treespec, possible_transports=None):
 
424
        from bzrlib import workingtree
431
425
        location, revno = treespec
432
426
        if revno is None:
433
427
            tree = workingtree.WorkingTree.open_containing(location)[0]
501
495
    def _add_parent(self):
502
496
        new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
503
497
        new_parent_trees = []
504
 
        operation = cleanup.OperationWithCleanups(
505
 
            self.this_tree.set_parent_trees)
 
498
        operation = OperationWithCleanups(self.this_tree.set_parent_trees)
506
499
        for revision_id in new_parents:
507
500
            try:
508
501
                tree = self.revision_tree(revision_id)
566
559
 
567
560
    def _maybe_fetch(self, source, target, revision_id):
568
561
        if not source.repository.has_same_location(target.repository):
569
 
            try:
570
 
                tags_to_fetch = set(source.tags.get_reverse_tag_dict())
571
 
            except errors.TagsNotSupported:
572
 
                tags_to_fetch = None
573
 
            fetch_spec = _mod_graph.NotInOtherForRevs(target.repository,
574
 
                source.repository, [revision_id],
575
 
                if_present_ids=tags_to_fetch).execute()
576
 
            target.fetch(source, fetch_spec=fetch_spec)
 
562
            target.fetch(source, revision_id)
577
563
 
578
564
    def find_base(self):
579
565
        revisions = [_mod_revision.ensure_null(self.this_basis),
590
576
            elif len(lcas) == 1:
591
577
                self.base_rev_id = list(lcas)[0]
592
578
            else: # len(lcas) > 1
593
 
                self._is_criss_cross = True
594
579
                if len(lcas) > 2:
595
580
                    # find_unique_lca can only handle 2 nodes, so we have to
596
581
                    # start back at the beginning. It is a shame to traverse
601
586
                else:
602
587
                    self.base_rev_id = self.revision_graph.find_unique_lca(
603
588
                                            *lcas)
604
 
                sorted_lca_keys = self.revision_graph.find_merge_order(                
605
 
                    revisions[0], lcas)
606
 
                if self.base_rev_id == _mod_revision.NULL_REVISION:
607
 
                    self.base_rev_id = sorted_lca_keys[0]
608
 
                
 
589
                self._is_criss_cross = True
609
590
            if self.base_rev_id == _mod_revision.NULL_REVISION:
610
591
                raise errors.UnrelatedBranches()
611
592
            if self._is_criss_cross:
612
593
                trace.warning('Warning: criss-cross merge encountered.  See bzr'
613
594
                              ' help criss-cross.')
614
595
                trace.mutter('Criss-cross lcas: %r' % lcas)
615
 
                if self.base_rev_id in lcas:
616
 
                    trace.mutter('Unable to find unique lca. '
617
 
                                 'Fallback %r as best option.' % self.base_rev_id)
618
 
                interesting_revision_ids = set(lcas)
619
 
                interesting_revision_ids.add(self.base_rev_id)
 
596
                interesting_revision_ids = [self.base_rev_id]
 
597
                interesting_revision_ids.extend(lcas)
620
598
                interesting_trees = dict((t.get_revision_id(), t)
621
599
                    for t in self.this_branch.repository.revision_trees(
622
600
                        interesting_revision_ids))
623
601
                self._cached_trees.update(interesting_trees)
624
 
                if self.base_rev_id in lcas:
625
 
                    self.base_tree = interesting_trees[self.base_rev_id]
626
 
                else:
627
 
                    self.base_tree = interesting_trees.pop(self.base_rev_id)
 
602
                self.base_tree = interesting_trees.pop(self.base_rev_id)
 
603
                sorted_lca_keys = self.revision_graph.find_merge_order(
 
604
                    revisions[0], lcas)
628
605
                self._lca_trees = [interesting_trees[key]
629
606
                                   for key in sorted_lca_keys]
630
607
            else:
709
686
        return merge
710
687
 
711
688
    def do_merge(self):
712
 
        operation = cleanup.OperationWithCleanups(self._do_merge_to)
 
689
        operation = OperationWithCleanups(self._do_merge_to)
713
690
        self.this_tree.lock_tree_write()
714
691
        operation.add_cleanup(self.this_tree.unlock)
715
692
        if self.base_tree is not None:
821
798
            warnings.warn("pb argument to Merge3Merger is deprecated")
822
799
 
823
800
    def do_merge(self):
824
 
        operation = cleanup.OperationWithCleanups(self._do_merge)
 
801
        operation = OperationWithCleanups(self._do_merge)
825
802
        self.this_tree.lock_tree_write()
826
803
        operation.add_cleanup(self.this_tree.unlock)
827
804
        self.base_tree.lock_read()
842
819
            pass
843
820
 
844
821
    def make_preview_transform(self):
845
 
        operation = cleanup.OperationWithCleanups(self._make_preview_transform)
 
822
        operation = OperationWithCleanups(self._make_preview_transform)
846
823
        self.base_tree.lock_read()
847
824
        operation.add_cleanup(self.base_tree.unlock)
848
825
        self.other_tree.lock_read()
879
856
        finally:
880
857
            child_pb.finished()
881
858
        self.fix_root()
882
 
        self._finish_computing_transform()
883
 
 
884
 
    def _finish_computing_transform(self):
885
 
        """Finalize the transform and report the changes.
886
 
 
887
 
        This is the second half of _compute_transform.
888
 
        """
889
859
        child_pb = ui.ui_factory.nested_progress_bar()
890
860
        try:
891
861
            fs_conflicts = transform.resolve_conflicts(self.tt, child_pb,
1101
1071
                          ))
1102
1072
        return result
1103
1073
 
 
1074
 
1104
1075
    def fix_root(self):
1105
 
        if self.tt.final_kind(self.tt.root) is None:
 
1076
        try:
 
1077
            self.tt.final_kind(self.tt.root)
 
1078
        except errors.NoSuchFile:
1106
1079
            self.tt.cancel_deletion(self.tt.root)
1107
1080
        if self.tt.final_file_id(self.tt.root) is None:
1108
1081
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
1117
1090
            # the other tree's root is a non-root in the current tree (as when
1118
1091
            # a previously unrelated branch is merged into another)
1119
1092
            return
1120
 
        if self.tt.final_kind(other_root) is not None:
 
1093
        try:
 
1094
            self.tt.final_kind(other_root)
1121
1095
            other_root_is_present = True
1122
 
        else:
 
1096
        except errors.NoSuchFile:
1123
1097
            # other_root doesn't have a physical representation. We still need
1124
1098
            # to move any references to the actual root of the tree.
1125
1099
            other_root_is_present = False
1129
1103
        for thing, child in self.other_tree.inventory.root.children.iteritems():
1130
1104
            trans_id = self.tt.trans_id_file_id(child.file_id)
1131
1105
            if not other_root_is_present:
1132
 
                if self.tt.final_kind(trans_id) is not None:
 
1106
                # FIXME: Make final_kind returns None instead of raising
 
1107
                # NoSuchFile to avoid the ugly construct below -- vila 20100402
 
1108
                try:
 
1109
                    self.tt.final_kind(trans_id)
1133
1110
                    # The item exist in the final tree and has a defined place
1134
1111
                    # to go already.
1135
1112
                    continue
 
1113
                except errors.NoSuchFile, e:
 
1114
                    pass
1136
1115
            # Move the item into the root
1137
1116
            self.tt.adjust_path(self.tt.final_name(trans_id),
1138
1117
                                self.tt.root, trans_id)
1414
1393
            self.tt.version_file(file_id, trans_id)
1415
1394
        # The merge has been performed, so the old contents should not be
1416
1395
        # retained.
1417
 
        self.tt.delete_contents(trans_id)
 
1396
        try:
 
1397
            self.tt.delete_contents(trans_id)
 
1398
        except errors.NoSuchFile:
 
1399
            pass
1418
1400
        return result
1419
1401
 
1420
1402
    def _default_other_winner_merge(self, merge_hook_params):
1473
1455
    def get_lines(self, tree, file_id):
1474
1456
        """Return the lines in a file, or an empty list."""
1475
1457
        if tree.has_id(file_id):
1476
 
            return tree.get_file_lines(file_id)
 
1458
            return tree.get_file(file_id).readlines()
1477
1459
        else:
1478
1460
            return []
1479
1461
 
1592
1574
        if winner == 'this' and file_status != "modified":
1593
1575
            return
1594
1576
        trans_id = self.tt.trans_id_file_id(file_id)
1595
 
        if self.tt.final_kind(trans_id) != "file":
 
1577
        try:
 
1578
            if self.tt.final_kind(trans_id) != "file":
 
1579
                return
 
1580
        except errors.NoSuchFile:
1596
1581
            return
1597
1582
        if winner == "this":
1598
1583
            executability = this_executable
1765
1750
            osutils.rmtree(temp_dir)
1766
1751
 
1767
1752
 
1768
 
class PathNotInTree(errors.BzrError):
1769
 
 
1770
 
    _fmt = """Merge-into failed because %(tree)s does not contain %(path)s."""
1771
 
 
1772
 
    def __init__(self, path, tree):
1773
 
        errors.BzrError.__init__(self, path=path, tree=tree)
1774
 
 
1775
 
 
1776
 
class MergeIntoMerger(Merger):
1777
 
    """Merger that understands other_tree will be merged into a subdir.
1778
 
 
1779
 
    This also changes the Merger api so that it uses real Branch, revision_id,
1780
 
    and RevisonTree objects, rather than using revision specs.
1781
 
    """
1782
 
 
1783
 
    def __init__(self, this_tree, other_branch, other_tree, target_subdir,
1784
 
            source_subpath, other_rev_id=None):
1785
 
        """Create a new MergeIntoMerger object.
1786
 
 
1787
 
        source_subpath in other_tree will be effectively copied to
1788
 
        target_subdir in this_tree.
1789
 
 
1790
 
        :param this_tree: The tree that we will be merging into.
1791
 
        :param other_branch: The Branch we will be merging from.
1792
 
        :param other_tree: The RevisionTree object we want to merge.
1793
 
        :param target_subdir: The relative path where we want to merge
1794
 
            other_tree into this_tree
1795
 
        :param source_subpath: The relative path specifying the subtree of
1796
 
            other_tree to merge into this_tree.
1797
 
        """
1798
 
        # It is assumed that we are merging a tree that is not in our current
1799
 
        # ancestry, which means we are using the "EmptyTree" as our basis.
1800
 
        null_ancestor_tree = this_tree.branch.repository.revision_tree(
1801
 
                                _mod_revision.NULL_REVISION)
1802
 
        super(MergeIntoMerger, self).__init__(
1803
 
            this_branch=this_tree.branch,
1804
 
            this_tree=this_tree,
1805
 
            other_tree=other_tree,
1806
 
            base_tree=null_ancestor_tree,
1807
 
            )
1808
 
        self._target_subdir = target_subdir
1809
 
        self._source_subpath = source_subpath
1810
 
        self.other_branch = other_branch
1811
 
        if other_rev_id is None:
1812
 
            other_rev_id = other_tree.get_revision_id()
1813
 
        self.other_rev_id = self.other_basis = other_rev_id
1814
 
        self.base_is_ancestor = True
1815
 
        self.backup_files = True
1816
 
        self.merge_type = Merge3Merger
1817
 
        self.show_base = False
1818
 
        self.reprocess = False
1819
 
        self.interesting_ids = None
1820
 
        self.merge_type = _MergeTypeParameterizer(MergeIntoMergeType,
1821
 
              target_subdir=self._target_subdir,
1822
 
              source_subpath=self._source_subpath)
1823
 
        if self._source_subpath != '':
1824
 
            # If this isn't a partial merge make sure the revisions will be
1825
 
            # present.
1826
 
            self._maybe_fetch(self.other_branch, self.this_branch,
1827
 
                self.other_basis)
1828
 
 
1829
 
    def set_pending(self):
1830
 
        if self._source_subpath != '':
1831
 
            return
1832
 
        Merger.set_pending(self)
1833
 
 
1834
 
 
1835
 
class _MergeTypeParameterizer(object):
1836
 
    """Wrap a merge-type class to provide extra parameters.
1837
 
    
1838
 
    This is hack used by MergeIntoMerger to pass some extra parameters to its
1839
 
    merge_type.  Merger.do_merge() sets up its own set of parameters to pass to
1840
 
    the 'merge_type' member.  It is difficult override do_merge without
1841
 
    re-writing the whole thing, so instead we create a wrapper which will pass
1842
 
    the extra parameters.
1843
 
    """
1844
 
 
1845
 
    def __init__(self, merge_type, **kwargs):
1846
 
        self._extra_kwargs = kwargs
1847
 
        self._merge_type = merge_type
1848
 
 
1849
 
    def __call__(self, *args, **kwargs):
1850
 
        kwargs.update(self._extra_kwargs)
1851
 
        return self._merge_type(*args, **kwargs)
1852
 
 
1853
 
    def __getattr__(self, name):
1854
 
        return getattr(self._merge_type, name)
1855
 
 
1856
 
 
1857
 
class MergeIntoMergeType(Merge3Merger):
1858
 
    """Merger that incorporates a tree (or part of a tree) into another."""
1859
 
 
1860
 
    def __init__(self, *args, **kwargs):
1861
 
        """Initialize the merger object.
1862
 
 
1863
 
        :param args: See Merge3Merger.__init__'s args.
1864
 
        :param kwargs: See Merge3Merger.__init__'s keyword args, except for
1865
 
            source_subpath and target_subdir.
1866
 
        :keyword source_subpath: The relative path specifying the subtree of
1867
 
            other_tree to merge into this_tree.
1868
 
        :keyword target_subdir: The relative path where we want to merge
1869
 
            other_tree into this_tree
1870
 
        """
1871
 
        # All of the interesting work happens during Merge3Merger.__init__(),
1872
 
        # so we have have to hack in to get our extra parameters set.
1873
 
        self._source_subpath = kwargs.pop('source_subpath')
1874
 
        self._target_subdir = kwargs.pop('target_subdir')
1875
 
        super(MergeIntoMergeType, self).__init__(*args, **kwargs)
1876
 
 
1877
 
    def _compute_transform(self):
1878
 
        child_pb = ui.ui_factory.nested_progress_bar()
1879
 
        try:
1880
 
            entries = self._entries_to_incorporate()
1881
 
            entries = list(entries)
1882
 
            for num, (entry, parent_id) in enumerate(entries):
1883
 
                child_pb.update('Preparing file merge', num, len(entries))
1884
 
                parent_trans_id = self.tt.trans_id_file_id(parent_id)
1885
 
                trans_id = transform.new_by_entry(self.tt, entry,
1886
 
                    parent_trans_id, self.other_tree)
1887
 
        finally:
1888
 
            child_pb.finished()
1889
 
        self._finish_computing_transform()
1890
 
 
1891
 
    def _entries_to_incorporate(self):
1892
 
        """Yields pairs of (inventory_entry, new_parent)."""
1893
 
        other_inv = self.other_tree.inventory
1894
 
        subdir_id = other_inv.path2id(self._source_subpath)
1895
 
        if subdir_id is None:
1896
 
            # XXX: The error would be clearer if it gave the URL of the source
1897
 
            # branch, but we don't have a reference to that here.
1898
 
            raise PathNotInTree(self._source_subpath, "Source tree")
1899
 
        subdir = other_inv[subdir_id]
1900
 
        parent_in_target = osutils.dirname(self._target_subdir)
1901
 
        target_id = self.this_tree.inventory.path2id(parent_in_target)
1902
 
        if target_id is None:
1903
 
            raise PathNotInTree(self._target_subdir, "Target tree")
1904
 
        name_in_target = osutils.basename(self._target_subdir)
1905
 
        merge_into_root = subdir.copy()
1906
 
        merge_into_root.name = name_in_target
1907
 
        if merge_into_root.file_id in self.this_tree.inventory:
1908
 
            # Give the root a new file-id.
1909
 
            # This can happen fairly easily if the directory we are
1910
 
            # incorporating is the root, and both trees have 'TREE_ROOT' as
1911
 
            # their root_id.  Users will expect this to Just Work, so we
1912
 
            # change the file-id here.
1913
 
            # Non-root file-ids could potentially conflict too.  That's really
1914
 
            # an edge case, so we don't do anything special for those.  We let
1915
 
            # them cause conflicts.
1916
 
            merge_into_root.file_id = generate_ids.gen_file_id(name_in_target)
1917
 
        yield (merge_into_root, target_id)
1918
 
        if subdir.kind != 'directory':
1919
 
            # No children, so we are done.
1920
 
            return
1921
 
        for ignored_path, entry in other_inv.iter_entries_by_dir(subdir_id):
1922
 
            parent_id = entry.parent_id
1923
 
            if parent_id == subdir.file_id:
1924
 
                # The root's parent ID has changed, so make sure children of
1925
 
                # the root refer to the new ID.
1926
 
                parent_id = merge_into_root.file_id
1927
 
            yield (entry, parent_id)
1928
 
 
1929
 
 
1930
1753
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
1931
1754
                backup_files=False,
1932
1755
                merge_type=Merge3Merger,
1940
1763
                change_reporter=None):
1941
1764
    """Primary interface for merging.
1942
1765
 
1943
 
    Typical use is probably::
1944
 
 
1945
 
        merge_inner(branch, branch.get_revision_tree(other_revision),
1946
 
                    branch.get_revision_tree(base_revision))
1947
 
    """
 
1766
        typical use is probably
 
1767
        'merge_inner(branch, branch.get_revision_tree(other_revision),
 
1768
                     branch.get_revision_tree(base_revision))'
 
1769
        """
1948
1770
    if this_tree is None:
1949
1771
        raise errors.BzrError("bzrlib.merge.merge_inner requires a this_tree "
1950
1772
                              "parameter as of bzrlib version 0.8.")