~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Martin Pool
  • Date: 2005-06-10 02:21:14 UTC
  • Revision ID: mbp@sourcefrog.net-20050610022114-8f49c9244a5b8e2f
- improved external-command patch from john

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Canonical Ltd
2
 
 
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
 
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
 
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
 
18
 
import os
 
1
from merge_core import merge_flex
 
2
from changeset import generate_changeset, ExceptionConflictHandler
 
3
from changeset import Inventory
 
4
from bzrlib import find_branch
 
5
import bzrlib.osutils
 
6
from bzrlib.errors import BzrCommandError
 
7
from bzrlib.diff import compare_trees
 
8
from trace import mutter, warning
 
9
import os.path
19
10
import tempfile
20
11
import shutil
21
12
import errno
22
 
from fetch import greedy_fetch
23
 
 
24
 
import bzrlib.osutils
25
 
import bzrlib.revision
26
 
from bzrlib.merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
27
 
from bzrlib.changeset import generate_changeset, ExceptionConflictHandler
28
 
from bzrlib.changeset import Inventory, Diff3Merge
29
 
from bzrlib.branch import find_branch
30
 
from bzrlib.errors import BzrCommandError, UnrelatedBranches, NoCommonAncestor
31
 
from bzrlib.errors import NoCommits
32
 
from bzrlib.delta import compare_trees
33
 
from bzrlib.trace import mutter, warning
34
 
from bzrlib.fetch import greedy_fetch
35
 
from bzrlib.revision import is_ancestor
36
 
 
37
 
# comments from abentley on irc: merge happens in two stages, each
38
 
# of which generates a changeset object
39
 
 
40
 
# stage 1: generate OLD->OTHER,
41
 
# stage 2: use MINE and OLD->OTHER to generate MINE -> RESULT
 
13
 
 
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
 
42
20
 
43
21
class MergeConflictHandler(ExceptionConflictHandler):
44
 
    """Handle conflicts encountered while merging.
45
 
 
46
 
    This subclasses ExceptionConflictHandler, so that any types of
47
 
    conflict that are not explicitly handled cause an exception and
48
 
    terminate the merge.
49
 
    """
 
22
    """Handle conflicts encountered while merging"""
50
23
    def __init__(self, dir, ignore_zero=False):
51
24
        ExceptionConflictHandler.__init__(self, dir)
52
25
        self.conflicts = 0
63
36
            d_file.write(line)
64
37
        os.chmod(dest, 0777 & os.stat(source).st_mode)
65
38
 
66
 
    def dump(self, lines, dest):
67
 
        """Copy the text and mode of a file
68
 
        :param source: The path of the file to copy
69
 
        :param dest: The distination file to create
70
 
        """
71
 
        d_file = file(dest, "wb")
72
 
        for line in lines:
73
 
            d_file.write(line)
74
 
 
75
39
    def add_suffix(self, name, suffix, last_new_name=None):
76
40
        """Rename a file to append a suffix.  If the new name exists, the
77
41
        suffix is added repeatedly until a non-existant name is found
96
60
        self.conflicts += 1
97
61
        
98
62
 
99
 
    def merge_conflict(self, new_file, this_path, base_lines, other_lines):
 
63
    def merge_conflict(self, new_file, this_path, base_path, other_path):
100
64
        """
101
65
        Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER.  The
102
66
        main file will be a version with diff3 conflicts.
106
70
        :param other_path: Path to the file text for the OTHER tree
107
71
        """
108
72
        self.add_suffix(this_path, ".THIS")
109
 
        self.dump(base_lines, this_path+".BASE")
110
 
        self.dump(other_lines, this_path+".OTHER")
 
73
        self.copy(base_path, this_path+".BASE")
 
74
        self.copy(other_path, this_path+".OTHER")
111
75
        os.rename(new_file, this_path)
112
76
        self.conflict("Diff3 conflict encountered in %s" % this_path)
113
77
 
114
 
    def new_contents_conflict(self, filename, other_contents):
115
 
        """Conflicting contents for newly added file."""
116
 
        self.copy(other_contents, filename + ".OTHER")
117
 
        self.conflict("Conflict in newly added file %s" % filename)
118
 
    
119
 
 
120
78
    def target_exists(self, entry, target, old_path):
121
79
        """Handle the case when the target file or dir exists"""
122
80
        moved_path = self.add_suffix(target, ".moved")
123
81
        self.conflict("Moved existing %s to %s" % (target, moved_path))
124
82
 
125
 
    def rmdir_non_empty(self, filename):
126
 
        """Handle the case where the dir to be removed still has contents"""
127
 
        self.conflict("Directory %s not removed because it is not empty"\
128
 
            % filename)
129
 
        return "skip"
130
 
 
131
83
    def finalize(self):
132
84
        if not self.ignore_zero:
133
85
            print "%d conflicts encountered.\n" % self.conflicts
134
86
            
135
 
def get_tree(treespec, temp_root, label, local_branch=None):
 
87
class SourceFile(object):
 
88
    def __init__(self, path, id, present=None, isdir=None):
 
89
        self.path = path
 
90
        self.id = id
 
91
        self.present = present
 
92
        self.isdir = isdir
 
93
        self.interesting = True
 
94
 
 
95
    def __repr__(self):
 
96
        return "SourceFile(%s, %s)" % (self.path, self.id)
 
97
 
 
98
def get_tree(treespec, temp_root, label):
136
99
    location, revno = treespec
137
100
    branch = find_branch(location)
138
101
    if revno is None:
139
 
        revision = None
 
102
        base_tree = branch.working_tree()
140
103
    elif revno == -1:
141
 
        revision = branch.last_patch()
142
 
    else:
143
 
        revision = branch.lookup_revision(revno)
144
 
    return branch, get_revid_tree(branch, revision, temp_root, label,
145
 
                                  local_branch)
146
 
 
147
 
def get_revid_tree(branch, revision, temp_root, label, local_branch):
148
 
    if revision is None:
149
 
        base_tree = branch.working_tree()
150
 
    else:
151
 
        if local_branch is not None:
152
 
            greedy_fetch(local_branch, branch, revision)
153
 
            base_tree = local_branch.revision_tree(revision)
154
 
        else:
155
 
            base_tree = branch.revision_tree(revision)
 
104
        base_tree = branch.basis_tree()
 
105
    else:
 
106
        base_tree = branch.revision_tree(branch.lookup_revision(revno))
156
107
    temp_path = os.path.join(temp_root, label)
157
108
    os.mkdir(temp_path)
158
 
    return MergeTree(base_tree, temp_path)
159
 
 
 
109
    return branch, MergeTree(base_tree, temp_path)
 
110
 
 
111
 
 
112
def abspath(tree, file_id):
 
113
    path = tree.inventory.id2path(file_id)
 
114
    if path == "":
 
115
        return "./."
 
116
    return "./" + path
160
117
 
161
118
def file_exists(tree, file_id):
162
119
    return tree.has_filename(tree.id2path(file_id))
163
120
    
 
121
def inventory_map(tree):
 
122
    inventory = {}
 
123
    for file_id in tree.inventory:
 
124
        if not file_exists(tree, file_id):
 
125
            continue
 
126
        path = abspath(tree, file_id)
 
127
        inventory[path] = SourceFile(path, file_id)
 
128
    return inventory
 
129
 
164
130
 
165
131
class MergeTree(object):
166
132
    def __init__(self, tree, tempdir):
169
135
            self.root = tree.basedir
170
136
        else:
171
137
            self.root = None
 
138
        self.inventory = inventory_map(tree)
172
139
        self.tree = tree
173
140
        self.tempdir = tempdir
174
141
        os.mkdir(os.path.join(self.tempdir, "texts"))
175
142
        self.cached = {}
176
143
 
177
 
    def __iter__(self):
178
 
        return self.tree.__iter__()
179
 
 
180
 
    def __contains__(self, file_id):
181
 
        return file_id in self.tree
182
 
 
183
 
    def get_file(self, file_id):
184
 
        return self.tree.get_file(file_id)
185
 
 
186
 
    def get_file_sha1(self, id):
187
 
        return self.tree.get_file_sha1(id)
188
 
 
189
 
    def id2path(self, file_id):
190
 
        return self.tree.id2path(file_id)
191
 
 
192
 
    def has_id(self, file_id):
193
 
        return self.tree.has_id(file_id)
194
 
 
195
 
    def has_or_had_id(self, file_id):
196
 
        if file_id == self.tree.inventory.root.file_id:
197
 
            return True
198
 
        return self.tree.inventory.has_id(file_id)
199
 
 
200
 
    def has_or_had_id(self, file_id):
201
 
        if file_id == self.tree.inventory.root.file_id:
202
 
            return True
203
 
        return self.tree.inventory.has_id(file_id)
204
 
 
205
144
    def readonly_path(self, id):
206
 
        if id not in self.tree:
207
 
            return None
208
145
        if self.root is not None:
209
146
            return self.tree.abspath(self.tree.id2path(id))
210
147
        else:
222
159
 
223
160
def merge(other_revision, base_revision,
224
161
          check_clean=True, ignore_zero=False,
225
 
          this_dir=None, backup_files=False, merge_type=ApplyMerge3,
226
 
          file_list=None):
 
162
          this_dir=None):
227
163
    """Merge changes into a tree.
228
164
 
229
165
    base_revision
230
 
        tuple(path, revision) Base for three-way merge.
 
166
        Base for three-way merge.
231
167
    other_revision
232
 
        tuple(path, revision) Other revision for three-way merge.
 
168
        Other revision for three-way merge.
233
169
    this_dir
234
170
        Directory to merge changes into; '.' by default.
235
171
    check_clean
236
172
        If true, this_dir must have no uncommitted changes before the
237
173
        merge begins.
238
 
    all available ancestors of other_revision and base_revision are
239
 
    automatically pulled into the branch.
240
174
    """
241
 
    from bzrlib.revision import common_ancestor, MultipleRevisionSources
242
 
    from bzrlib.errors import NoSuchRevision
243
175
    tempdir = tempfile.mkdtemp(prefix="bzr-")
244
176
    try:
245
177
        if this_dir is None:
246
178
            this_dir = '.'
247
179
        this_branch = find_branch(this_dir)
248
 
        this_rev_id = this_branch.last_patch()
249
 
        if this_rev_id is None:
250
 
            raise BzrCommandError("This branch has no commits")
251
180
        if check_clean:
252
181
            changes = compare_trees(this_branch.working_tree(), 
253
182
                                    this_branch.basis_tree(), False)
254
183
            if changes.has_changed():
255
184
                raise BzrCommandError("Working tree has uncommitted changes.")
256
 
        other_branch, other_tree = get_tree(other_revision, tempdir, "other",
257
 
                                            this_branch)
258
 
        if other_revision[1] == -1:
259
 
            other_rev_id = other_branch.last_patch()
260
 
            if other_rev_id is None:
261
 
                raise NoCommits(other_branch)
262
 
            other_basis = other_rev_id
263
 
        elif other_revision[1] is not None:
264
 
            other_rev_id = other_branch.lookup_revision(other_revision[1])
265
 
            other_basis = other_rev_id
266
 
        else:
267
 
            other_rev_id = None
268
 
            other_basis = other_branch.last_patch()
269
 
            if other_basis is None:
270
 
                raise NoCommits(other_branch)
 
185
        other_branch, other_tree = get_tree(other_revision, tempdir, "other")
271
186
        if base_revision == [None, None]:
272
 
            try:
273
 
                base_rev_id = common_ancestor(this_rev_id, other_basis, 
274
 
                                              this_branch)
275
 
            except NoCommonAncestor:
 
187
            if other_revision[1] == -1:
 
188
                o_revno = None
 
189
            else:
 
190
                o_revno = other_revision[1]
 
191
            base_revno = this_branch.common_ancestor(other_branch, 
 
192
                                                     other_revno=o_revno)[0]
 
193
            if base_revno is None:
276
194
                raise UnrelatedBranches()
277
 
            base_tree = get_revid_tree(this_branch, base_rev_id, tempdir, 
278
 
                                       "base", None)
279
 
            base_is_ancestor = True
280
 
        else:
281
 
            base_branch, base_tree = get_tree(base_revision, tempdir, "base")
282
 
            if base_revision[1] == -1:
283
 
                base_rev_id = base_branch.last_patch()
284
 
            elif base_revision[1] is None:
285
 
                base_rev_id = None
286
 
            else:
287
 
                base_rev_id = base_branch.lookup_revision(base_revision[1])
288
 
            if base_rev_id is not None:
289
 
                base_is_ancestor = is_ancestor(this_rev_id, base_rev_id, 
290
 
                                               MultipleRevisionSources(this_branch, 
291
 
                                                                       base_branch))
292
 
            else:
293
 
                base_is_ancestor = False
294
 
        if file_list is None:
295
 
            interesting_ids = None
296
 
        else:
297
 
            interesting_ids = set()
298
 
            this_tree = this_branch.working_tree()
299
 
            for fname in file_list:
300
 
                path = this_branch.relpath(fname)
301
 
                found_id = False
302
 
                for tree in (this_tree, base_tree.tree, other_tree.tree):
303
 
                    file_id = tree.inventory.path2id(path)
304
 
                    if file_id is not None:
305
 
                        interesting_ids.add(file_id)
306
 
                        found_id = True
307
 
                if not found_id:
308
 
                    raise BzrCommandError("%s is not a source file in any"
309
 
                                          " tree." % fname)
 
195
            base_revision = ['.', base_revno]
 
196
        base_branch, base_tree = get_tree(base_revision, tempdir, "base")
310
197
        merge_inner(this_branch, other_tree, base_tree, tempdir, 
311
 
                    ignore_zero=ignore_zero, backup_files=backup_files, 
312
 
                    merge_type=merge_type, interesting_ids=interesting_ids)
313
 
        if base_is_ancestor and other_rev_id is not None\
314
 
            and other_rev_id not in this_branch.revision_history():
315
 
            this_branch.add_pending_merge(other_rev_id)
 
198
                    ignore_zero=ignore_zero)
316
199
    finally:
317
200
        shutil.rmtree(tempdir)
318
201
 
319
202
 
320
 
def set_interesting(inventory_a, inventory_b, interesting_ids):
321
 
    """Mark files whose ids are in interesting_ids as interesting
322
 
    """
323
 
    for inventory in (inventory_a, inventory_b):
324
 
        for path, source_file in inventory.iteritems():
325
 
             source_file.interesting = source_file.id in interesting_ids
326
 
 
327
 
 
328
 
def generate_cset_optimized(tree_a, tree_b, interesting_ids=None):
329
 
    """Generate a changeset.  If interesting_ids is supplied, only changes
330
 
    to those files will be shown.  Metadata changes are stripped.
 
203
def generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b):
 
204
    """Generate a changeset, using the text_id to mark really-changed files.
 
205
    This permits blazing comparisons when text_ids are present.  It also
 
206
    disables metadata comparison for files with identical texts.
331
207
    """ 
332
 
    cset =  generate_changeset(tree_a, tree_b, interesting_ids)
 
208
    for file_id in tree_a.tree.inventory:
 
209
        if file_id not in tree_b.tree.inventory:
 
210
            continue
 
211
        entry_a = tree_a.tree.inventory[file_id]
 
212
        entry_b = tree_b.tree.inventory[file_id]
 
213
        if (entry_a.kind, entry_b.kind) != ("file", "file"):
 
214
            continue
 
215
        if None in (entry_a.text_id, entry_b.text_id):
 
216
            continue
 
217
        if entry_a.text_id != entry_b.text_id:
 
218
            continue
 
219
        inventory_a[abspath(tree_a.tree, file_id)].interesting = False
 
220
        inventory_b[abspath(tree_b.tree, file_id)].interesting = False
 
221
    cset =  generate_changeset(tree_a, tree_b, inventory_a, inventory_b)
333
222
    for entry in cset.entries.itervalues():
334
223
        entry.metadata_change = None
335
224
    return cset
336
225
 
337
226
 
338
227
def merge_inner(this_branch, other_tree, base_tree, tempdir, 
339
 
                ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
340
 
                interesting_ids=None):
341
 
 
342
 
    def merge_factory(file_id, base, other):
343
 
        contents_change = merge_type(file_id, base, other)
344
 
        if backup_files:
345
 
            contents_change = BackupBeforeChange(contents_change)
346
 
        return contents_change
347
 
 
 
228
                ignore_zero=False):
348
229
    this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
349
230
 
350
231
    def get_inventory(tree):
351
 
        return tree.tree.inventory
 
232
        return tree.inventory
352
233
 
353
234
    inv_changes = merge_flex(this_tree, base_tree, other_tree,
354
235
                             generate_cset_optimized, get_inventory,
355
236
                             MergeConflictHandler(base_tree.root,
356
 
                                                  ignore_zero=ignore_zero),
357
 
                             merge_factory=merge_factory, 
358
 
                             interesting_ids=interesting_ids)
 
237
                                                  ignore_zero=ignore_zero))
359
238
 
360
239
    adjust_ids = []
361
240
    for id, path in inv_changes.iteritems():
363
242
            if path == '.':
364
243
                path = ''
365
244
            else:
366
 
                assert path.startswith('.' + os.sep), "path is %s" % path
 
245
                assert path.startswith('./')
367
246
            path = path[2:]
368
247
        adjust_ids.append((path, id))
369
 
    if len(adjust_ids) > 0:
370
 
        this_branch.set_inventory(regen_inventory(this_branch, this_tree.root,
371
 
                                                  adjust_ids))
 
248
    this_branch.set_inventory(regen_inventory(this_branch, this_tree.root, adjust_ids))
372
249
 
373
250
 
374
251
def regen_inventory(this_branch, root, new_entries):
375
252
    old_entries = this_branch.read_working_inventory()
376
253
    new_inventory = {}
377
254
    by_path = {}
378
 
    new_entries_map = {} 
379
 
    for path, file_id in new_entries:
380
 
        if path is None:
381
 
            continue
382
 
        new_entries_map[file_id] = path
383
 
 
384
 
    def id2path(file_id):
385
 
        path = new_entries_map.get(file_id)
386
 
        if path is not None:
387
 
            return path
388
 
        entry = old_entries[file_id]
389
 
        if entry.parent_id is None:
390
 
            return entry.name
391
 
        return os.path.join(id2path(entry.parent_id), entry.name)
392
 
        
393
255
    for file_id in old_entries:
394
256
        entry = old_entries[file_id]
395
 
        path = id2path(file_id)
 
257
        path = old_entries.id2path(file_id)
396
258
        new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
397
259
        by_path[path] = file_id
398
260
    
426
288
    assert len(new_inventory_list) == len(old_entries) + insertions - deletions
427
289
    new_inventory_list.sort()
428
290
    return new_inventory_list
429
 
 
430
 
merge_types = {     "merge3": (ApplyMerge3, "Native diff3-style merge"), 
431
 
                     "diff3": (Diff3Merge,  "Merge using external diff3")
432
 
              }
433