← 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 09:05:11 UTC
  • Revision ID: mbp@sourcefrog.net-20050517090511-b026ebbb9060034c
- file-ids are stored as quoted-printable in the stat cache,
  so as to better handle any wierd values that may be present.
- more sanity checks on records read from stat cache

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
 
from bzrlib.merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
2
 
from bzrlib.changeset import generate_changeset, ExceptionConflictHandler
3
 
from bzrlib.changeset import Inventory, Diff3Merge
4
 
from bzrlib import find_branch
 
1
from merge_core import merge_flex
 
2
from changeset import generate_changeset, ExceptionConflictHandler
 
3
from changeset import Inventory
 
4
from bzrlib import Branch
5
5
import bzrlib.osutils
6
 
from bzrlib.errors import BzrCommandError
7
 
from bzrlib.delta 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
 
 
15
 
# comments from abentley on irc: merge happens in two stages, each
16
 
# of which generates a changeset object
17
 
 
18
 
# stage 1: generate OLD->OTHER,
19
 
# stage 2: use MINE and OLD->OTHER to generate MINE -> RESULT
20
 
 
21
 
class UnrelatedBranches(BzrCommandError):
22
 
    def __init__(self):
23
 
        msg = "Branches have no common ancestor, and no base revision"\
24
 
            " specified."
25
 
        BzrCommandError.__init__(self, msg)
26
 
 
27
 
 
28
12
class MergeConflictHandler(ExceptionConflictHandler):
29
 
    """Handle conflicts encountered while merging.
30
 
 
31
 
    This subclasses ExceptionConflictHandler, so that any types of
32
 
    conflict that are not explicitly handled cause an exception and
33
 
    terminate the merge.
34
 
    """
35
 
    def __init__(self, dir, ignore_zero=False):
36
 
        ExceptionConflictHandler.__init__(self, dir)
37
 
        self.conflicts = 0
38
 
        self.ignore_zero = ignore_zero
39
 
 
 
13
    """Handle conflicts encountered while merging"""
40
14
    def copy(self, source, dest):
41
15
        """Copy the text and mode of a file
42
16
        :param source: The path of the file to copy
48
22
            d_file.write(line)
49
23
        os.chmod(dest, 0777 & os.stat(source).st_mode)
50
24
 
51
 
    def dump(self, lines, dest):
52
 
        """Copy the text and mode of a file
53
 
        :param source: The path of the file to copy
54
 
        :param dest: The distination file to create
55
 
        """
56
 
        d_file = file(dest, "wb")
57
 
        for line in lines:
58
 
            d_file.write(line)
59
 
 
60
25
    def add_suffix(self, name, suffix, last_new_name=None):
61
26
        """Rename a file to append a suffix.  If the new name exists, the
62
27
        suffix is added repeatedly until a non-existant name is found
70
35
        new_name = last_new_name+suffix
71
36
        try:
72
37
            os.rename(name, new_name)
73
 
            return new_name
74
38
        except OSError, e:
75
39
            if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
76
40
                raise
77
 
            return self.add_suffix(name, suffix, last_new_name=new_name)
78
 
 
79
 
    def conflict(self, text):
80
 
        warning(text)
81
 
        self.conflicts += 1
82
 
        
83
 
 
84
 
    def merge_conflict(self, new_file, this_path, base_lines, other_lines):
 
41
            self.add_suffix(name, suffix, last_new_name=new_name)
 
42
 
 
43
    def merge_conflict(self, new_file, this_path, base_path, other_path):
85
44
        """
86
45
        Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER.  The
87
46
        main file will be a version with diff3 conflicts.
91
50
        :param other_path: Path to the file text for the OTHER tree
92
51
        """
93
52
        self.add_suffix(this_path, ".THIS")
94
 
        self.dump(base_lines, this_path+".BASE")
95
 
        self.dump(other_lines, this_path+".OTHER")
 
53
        self.copy(base_path, this_path+".BASE")
 
54
        self.copy(other_path, this_path+".OTHER")
96
55
        os.rename(new_file, this_path)
97
 
        self.conflict("Diff3 conflict encountered in %s" % this_path)
98
 
 
99
 
    def new_contents_conflict(self, filename, other_contents):
100
 
        """Conflicting contents for newly added file."""
101
 
        self.copy(other_contents, filename + ".OTHER")
102
 
        self.conflict("Conflict in newly added file %s" % filename)
103
 
    
104
56
 
105
57
    def target_exists(self, entry, target, old_path):
106
58
        """Handle the case when the target file or dir exists"""
107
 
        moved_path = self.add_suffix(target, ".moved")
108
 
        self.conflict("Moved existing %s to %s" % (target, moved_path))
109
 
 
110
 
    def rmdir_non_empty(self, filename):
111
 
        """Handle the case where the dir to be removed still has contents"""
112
 
        self.conflict("Directory %s not removed because it is not empty"\
113
 
            % filename)
114
 
        return "skip"
115
 
 
116
 
    def finalize(self):
117
 
        if not self.ignore_zero:
118
 
            print "%d conflicts encountered.\n" % self.conflicts
 
59
        self.add_suffix(target, ".moved")
119
60
            
 
61
class SourceFile:
 
62
    def __init__(self, path, id, present=None, isdir=None):
 
63
        self.path = path
 
64
        self.id = id
 
65
        self.present = present
 
66
        self.isdir = isdir
 
67
        self.interesting = True
 
68
 
 
69
    def __repr__(self):
 
70
        return "SourceFile(%s, %s)" % (self.path, self.id)
 
71
 
120
72
def get_tree(treespec, temp_root, label):
121
 
    location, revno = treespec
122
 
    branch = find_branch(location)
 
73
    dir, revno = treespec
 
74
    branch = Branch(dir)
123
75
    if revno is None:
124
76
        base_tree = branch.working_tree()
125
77
    elif revno == -1:
128
80
        base_tree = branch.revision_tree(branch.lookup_revision(revno))
129
81
    temp_path = os.path.join(temp_root, label)
130
82
    os.mkdir(temp_path)
131
 
    return branch, MergeTree(base_tree, temp_path)
132
 
 
 
83
    return MergeTree(base_tree, temp_path)
 
84
 
 
85
 
 
86
def abspath(tree, file_id):
 
87
    path = tree.inventory.id2path(file_id)
 
88
    if path == "":
 
89
        return "./."
 
90
    return "./" + path
133
91
 
134
92
def file_exists(tree, file_id):
135
93
    return tree.has_filename(tree.id2path(file_id))
136
94
    
 
95
def inventory_map(tree):
 
96
    inventory = {}
 
97
    for file_id in tree.inventory:
 
98
        if not file_exists(tree, file_id):
 
99
            continue
 
100
        path = abspath(tree, file_id)
 
101
        inventory[path] = SourceFile(path, file_id)
 
102
    return inventory
 
103
 
137
104
 
138
105
class MergeTree(object):
139
106
    def __init__(self, tree, tempdir):
142
109
            self.root = tree.basedir
143
110
        else:
144
111
            self.root = None
 
112
        self.inventory = inventory_map(tree)
145
113
        self.tree = tree
146
114
        self.tempdir = tempdir
147
115
        os.mkdir(os.path.join(self.tempdir, "texts"))
148
116
        self.cached = {}
149
117
 
150
 
    def __iter__(self):
151
 
        return self.tree.__iter__()
152
 
 
153
 
    def __contains__(self, file_id):
154
 
        return file_id in self.tree
155
 
 
156
 
    def get_file(self, file_id):
157
 
        return self.tree.get_file(file_id)
158
 
 
159
 
    def get_file_sha1(self, id):
160
 
        return self.tree.get_file_sha1(id)
161
 
 
162
 
    def id2path(self, file_id):
163
 
        return self.tree.id2path(file_id)
164
 
 
165
 
    def has_id(self, file_id):
166
 
        return self.tree.has_id(file_id)
167
 
 
168
118
    def readonly_path(self, id):
169
 
        if id not in self.tree:
170
 
            return None
171
119
        if self.root is not None:
172
120
            return self.tree.abspath(self.tree.id2path(id))
173
121
        else:
181
129
                self.cached[id] = path
182
130
            return self.cached[id]
183
131
 
184
 
 
185
 
 
186
 
def merge(other_revision, base_revision,
187
 
          check_clean=True, ignore_zero=False,
188
 
          this_dir=None, backup_files=False, merge_type=ApplyMerge3,
189
 
          file_list=None):
190
 
    """Merge changes into a tree.
191
 
 
192
 
    base_revision
193
 
        Base for three-way merge.
194
 
    other_revision
195
 
        Other revision for three-way merge.
196
 
    this_dir
197
 
        Directory to merge changes into; '.' by default.
198
 
    check_clean
199
 
        If true, this_dir must have no uncommitted changes before the
200
 
        merge begins.
201
 
    """
 
132
def merge(other_revision, base_revision):
202
133
    tempdir = tempfile.mkdtemp(prefix="bzr-")
203
134
    try:
204
 
        if this_dir is None:
205
 
            this_dir = '.'
206
 
        this_branch = find_branch(this_dir)
207
 
        if check_clean:
208
 
            changes = compare_trees(this_branch.working_tree(), 
209
 
                                    this_branch.basis_tree(), False)
210
 
            if changes.has_changed():
211
 
                raise BzrCommandError("Working tree has uncommitted changes.")
212
 
        other_branch, other_tree = get_tree(other_revision, tempdir, "other")
213
 
        if base_revision == [None, None]:
214
 
            if other_revision[1] == -1:
215
 
                o_revno = None
216
 
            else:
217
 
                o_revno = other_revision[1]
218
 
            base_revno = this_branch.common_ancestor(other_branch, 
219
 
                                                     other_revno=o_revno)[0]
220
 
            if base_revno is None:
221
 
                raise UnrelatedBranches()
222
 
            base_revision = ['.', base_revno]
223
 
        base_branch, base_tree = get_tree(base_revision, tempdir, "base")
224
 
        if file_list is None:
225
 
            interesting_ids = None
226
 
        else:
227
 
            interesting_ids = set()
228
 
            this_tree = this_branch.working_tree()
229
 
            for fname in file_list:
230
 
                path = this_branch.relpath(fname)
231
 
                found_id = False
232
 
                for tree in (this_tree, base_tree.tree, other_tree.tree):
233
 
                    file_id = tree.inventory.path2id(path)
234
 
                    if file_id is not None:
235
 
                        interesting_ids.add(file_id)
236
 
                        found_id = True
237
 
                if not found_id:
238
 
                    raise BzrCommandError("%s is not a source file in any"
239
 
                                          " tree." % fname)
240
 
        merge_inner(this_branch, other_tree, base_tree, tempdir, 
241
 
                    ignore_zero=ignore_zero, backup_files=backup_files, 
242
 
                    merge_type=merge_type, interesting_ids=interesting_ids)
 
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)
243
139
    finally:
244
140
        shutil.rmtree(tempdir)
245
141
 
246
142
 
247
 
def set_interesting(inventory_a, inventory_b, interesting_ids):
248
 
    """Mark files whose ids are in interesting_ids as interesting
249
 
    """
250
 
    for inventory in (inventory_a, inventory_b):
251
 
        for path, source_file in inventory.iteritems():
252
 
             source_file.interesting = source_file.id in interesting_ids
253
 
 
254
 
 
255
 
def generate_cset_optimized(tree_a, tree_b, interesting_ids=None):
256
 
    """Generate a changeset.  If interesting_ids is supplied, only changes
257
 
    to those files will be shown.  Metadata changes are stripped.
 
143
def generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b):
 
144
    """Generate a changeset, using the text_id to mark really-changed files.
 
145
    This permits blazing comparisons when text_ids are present.  It also
 
146
    disables metadata comparison for files with identical texts.
258
147
    """ 
259
 
    cset =  generate_changeset(tree_a, tree_b, interesting_ids)
 
148
    for file_id in tree_a.tree.inventory:
 
149
        if file_id not in tree_b.tree.inventory:
 
150
            continue
 
151
        entry_a = tree_a.tree.inventory[file_id]
 
152
        entry_b = tree_b.tree.inventory[file_id]
 
153
        if (entry_a.kind, entry_b.kind) != ("file", "file"):
 
154
            continue
 
155
        if None in (entry_a.text_id, entry_b.text_id):
 
156
            continue
 
157
        if entry_a.text_id != entry_b.text_id:
 
158
            continue
 
159
        inventory_a[abspath(tree_a.tree, file_id)].interesting = False
 
160
        inventory_b[abspath(tree_b.tree, file_id)].interesting = False
 
161
    cset =  generate_changeset(tree_a, tree_b, inventory_a, inventory_b)
260
162
    for entry in cset.entries.itervalues():
261
163
        entry.metadata_change = None
262
164
    return cset
263
165
 
264
166
 
265
 
def merge_inner(this_branch, other_tree, base_tree, tempdir, 
266
 
                ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
267
 
                interesting_ids=None):
268
 
 
269
 
    def merge_factory(file_id, base, other):
270
 
        contents_change = merge_type(file_id, base, other)
271
 
        if backup_files:
272
 
            contents_change = BackupBeforeChange(contents_change)
273
 
        return contents_change
274
 
 
275
 
    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")
276
169
 
277
170
    def get_inventory(tree):
278
 
        return tree.tree.inventory
 
171
        return tree.inventory
279
172
 
280
173
    inv_changes = merge_flex(this_tree, base_tree, other_tree,
281
174
                             generate_cset_optimized, get_inventory,
282
 
                             MergeConflictHandler(base_tree.root,
283
 
                                                  ignore_zero=ignore_zero),
284
 
                             merge_factory=merge_factory, 
285
 
                             interesting_ids=interesting_ids)
 
175
                             MergeConflictHandler(base_tree.root))
286
176
 
287
177
    adjust_ids = []
288
178
    for id, path in inv_changes.iteritems():
290
180
            if path == '.':
291
181
                path = ''
292
182
            else:
293
 
                assert path.startswith('./'), "path is %s" % path
 
183
                assert path.startswith('./')
294
184
            path = path[2:]
295
185
        adjust_ids.append((path, id))
296
 
    if len(adjust_ids) > 0:
297
 
        this_branch.set_inventory(regen_inventory(this_branch, this_tree.root,
298
 
                                                  adjust_ids))
 
186
    this_branch.set_inventory(regen_inventory(this_branch, this_tree.root, adjust_ids))
299
187
 
300
188
 
301
189
def regen_inventory(this_branch, root, new_entries):
302
190
    old_entries = this_branch.read_working_inventory()
303
191
    new_inventory = {}
304
192
    by_path = {}
305
 
    new_entries_map = {} 
306
 
    for path, file_id in new_entries:
307
 
        if path is None:
308
 
            continue
309
 
        new_entries_map[file_id] = path
310
 
 
311
 
    def id2path(file_id):
312
 
        path = new_entries_map.get(file_id)
313
 
        if path is not None:
314
 
            return path
315
 
        entry = old_entries[file_id]
316
 
        if entry.parent_id is None:
317
 
            return entry.name
318
 
        return os.path.join(id2path(entry.parent_id), entry.name)
319
 
        
320
193
    for file_id in old_entries:
321
194
        entry = old_entries[file_id]
322
 
        path = id2path(file_id)
 
195
        path = old_entries.id2path(file_id)
323
196
        new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
324
197
        by_path[path] = file_id
325
198
    
353
226
    assert len(new_inventory_list) == len(old_entries) + insertions - deletions
354
227
    new_inventory_list.sort()
355
228
    return new_inventory_list
356
 
 
357
 
merge_types = {     "merge3": (ApplyMerge3, "Native diff3-style merge"), 
358
 
                     "diff3": (Diff3Merge,  "Merge using external diff3")
359
 
              }
360