← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Martin Pool
  • Date: 2005-05-17 06:56:16 UTC
  • Revision ID: mbp@sourcefrog.net-20050517065616-6f23381d6184a8aa
- add space for un-merged patches

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
1
from merge_core import merge_flex
2
2
from changeset import generate_changeset, ExceptionConflictHandler
3
3
from changeset import Inventory
4
 
from bzrlib import find_branch
 
4
from bzrlib import Branch
5
5
import bzrlib.osutils
6
 
from bzrlib.errors import BzrCommandError
7
 
from bzrlib.diff import compare_trees
8
 
from trace import mutter, warning
 
6
from trace import mutter
9
7
import os.path
10
8
import tempfile
11
9
import shutil
12
10
import errno
13
11
 
14
 
class UnrelatedBranches(BzrCommandError):
15
 
    def __init__(self):
16
 
        msg = "Branches have no common ancestor, and no base revision"\
17
 
            " specified."
18
 
        BzrCommandError.__init__(self, msg)
19
 
 
20
 
 
21
12
class MergeConflictHandler(ExceptionConflictHandler):
22
13
    """Handle conflicts encountered while merging"""
23
 
    def __init__(self, dir, ignore_zero=False):
24
 
        ExceptionConflictHandler.__init__(self, dir)
25
 
        self.conflicts = 0
26
 
        self.ignore_zero = ignore_zero
27
 
 
28
14
    def copy(self, source, dest):
29
15
        """Copy the text and mode of a file
30
16
        :param source: The path of the file to copy
49
35
        new_name = last_new_name+suffix
50
36
        try:
51
37
            os.rename(name, new_name)
52
 
            return new_name
53
38
        except OSError, e:
54
39
            if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
55
40
                raise
56
 
            return self.add_suffix(name, suffix, last_new_name=new_name)
57
 
 
58
 
    def conflict(self, text):
59
 
        warning(text)
60
 
        self.conflicts += 1
61
 
        
 
41
            self.add_suffix(name, suffix, last_new_name=new_name)
62
42
 
63
43
    def merge_conflict(self, new_file, this_path, base_path, other_path):
64
44
        """
73
53
        self.copy(base_path, this_path+".BASE")
74
54
        self.copy(other_path, this_path+".OTHER")
75
55
        os.rename(new_file, this_path)
76
 
        self.conflict("Diff3 conflict encountered in %s" % this_path)
77
56
 
78
57
    def target_exists(self, entry, target, old_path):
79
58
        """Handle the case when the target file or dir exists"""
80
 
        moved_path = self.add_suffix(target, ".moved")
81
 
        self.conflict("Moved existing %s to %s" % (target, moved_path))
82
 
 
83
 
    def rmdir_non_empty(self, filename):
84
 
        """Handle the case where the dir to be removed still has contents"""
85
 
        self.conflict("Directory %s not removed because it is not empty"\
86
 
            % filename)
87
 
        return "skip"
88
 
 
89
 
    def finalize(self):
90
 
        if not self.ignore_zero:
91
 
            print "%d conflicts encountered.\n" % self.conflicts
 
59
        self.add_suffix(target, ".moved")
92
60
            
93
 
class SourceFile(object):
 
61
class SourceFile:
94
62
    def __init__(self, path, id, present=None, isdir=None):
95
63
        self.path = path
96
64
        self.id = id
102
70
        return "SourceFile(%s, %s)" % (self.path, self.id)
103
71
 
104
72
def get_tree(treespec, temp_root, label):
105
 
    location, revno = treespec
106
 
    branch = find_branch(location)
 
73
    dir, revno = treespec
 
74
    branch = Branch(dir)
107
75
    if revno is None:
108
76
        base_tree = branch.working_tree()
109
77
    elif revno == -1:
112
80
        base_tree = branch.revision_tree(branch.lookup_revision(revno))
113
81
    temp_path = os.path.join(temp_root, label)
114
82
    os.mkdir(temp_path)
115
 
    return branch, MergeTree(base_tree, temp_path)
 
83
    return MergeTree(base_tree, temp_path)
116
84
 
117
85
 
118
86
def abspath(tree, file_id):
127
95
def inventory_map(tree):
128
96
    inventory = {}
129
97
    for file_id in tree.inventory:
 
98
        if not file_exists(tree, file_id):
 
99
            continue
130
100
        path = abspath(tree, file_id)
131
101
        inventory[path] = SourceFile(path, file_id)
132
102
    return inventory
146
116
        self.cached = {}
147
117
 
148
118
    def readonly_path(self, id):
149
 
        if id not in self.tree:
150
 
            return None
151
119
        if self.root is not None:
152
120
            return self.tree.abspath(self.tree.id2path(id))
153
121
        else:
161
129
                self.cached[id] = path
162
130
            return self.cached[id]
163
131
 
164
 
 
165
 
 
166
 
def merge(other_revision, base_revision,
167
 
          check_clean=True, ignore_zero=False,
168
 
          this_dir=None):
169
 
    """Merge changes into a tree.
170
 
 
171
 
    base_revision
172
 
        Base for three-way merge.
173
 
    other_revision
174
 
        Other revision for three-way merge.
175
 
    this_dir
176
 
        Directory to merge changes into; '.' by default.
177
 
    check_clean
178
 
        If true, this_dir must have no uncommitted changes before the
179
 
        merge begins.
180
 
    """
 
132
def merge(other_revision, base_revision):
181
133
    tempdir = tempfile.mkdtemp(prefix="bzr-")
182
134
    try:
183
 
        if this_dir is None:
184
 
            this_dir = '.'
185
 
        this_branch = find_branch(this_dir)
186
 
        if check_clean:
187
 
            changes = compare_trees(this_branch.working_tree(), 
188
 
                                    this_branch.basis_tree(), False)
189
 
            if changes.has_changed():
190
 
                raise BzrCommandError("Working tree has uncommitted changes.")
191
 
        other_branch, other_tree = get_tree(other_revision, tempdir, "other")
192
 
        if base_revision == [None, None]:
193
 
            if other_revision[1] == -1:
194
 
                o_revno = None
195
 
            else:
196
 
                o_revno = other_revision[1]
197
 
            base_revno = this_branch.common_ancestor(other_branch, 
198
 
                                                     other_revno=o_revno)[0]
199
 
            if base_revno is None:
200
 
                raise UnrelatedBranches()
201
 
            base_revision = ['.', base_revno]
202
 
        base_branch, base_tree = get_tree(base_revision, tempdir, "base")
203
 
        merge_inner(this_branch, other_tree, base_tree, tempdir, 
204
 
                    ignore_zero=ignore_zero)
 
135
        this_branch = Branch('.') 
 
136
        other_tree = get_tree(other_revision, tempdir, "other")
 
137
        base_tree = get_tree(base_revision, tempdir, "base")
 
138
        merge_inner(this_branch, other_tree, base_tree, tempdir)
205
139
    finally:
206
140
        shutil.rmtree(tempdir)
207
141
 
230
164
    return cset
231
165
 
232
166
 
233
 
def merge_inner(this_branch, other_tree, base_tree, tempdir, 
234
 
                ignore_zero=False):
235
 
    this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
 
167
def merge_inner(this_branch, other_tree, base_tree, tempdir):
 
168
    this_tree = get_tree(('.', None), tempdir, "this")
236
169
 
237
170
    def get_inventory(tree):
238
171
        return tree.inventory
239
172
 
240
173
    inv_changes = merge_flex(this_tree, base_tree, other_tree,
241
174
                             generate_cset_optimized, get_inventory,
242
 
                             MergeConflictHandler(base_tree.root,
243
 
                                                  ignore_zero=ignore_zero))
 
175
                             MergeConflictHandler(base_tree.root))
244
176
 
245
177
    adjust_ids = []
246
178
    for id, path in inv_changes.iteritems():