← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: aaron.bentley at utoronto
  • Date: 2005-08-21 00:08:08 UTC
  • mto: (1092.1.41) (1185.3.4)
  • mto: This revision was merged to the branch mainline in revision 1110.
  • Revision ID: aaron.bentley@utoronto.ca-20050821000808-2a0e6ef95b1bca59
Changed copy_multi to permit failure and return a tuple, tested missing required revisions

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
 
from merge_core import merge_flex
2
 
from changeset import generate_changeset, ExceptionConflictHandler
3
 
from changeset import Inventory
 
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
4
from bzrlib import find_branch
5
5
import bzrlib.osutils
6
6
from bzrlib.errors import BzrCommandError
7
 
from bzrlib.diff import compare_trees
 
7
from bzrlib.delta import compare_trees
8
8
from trace import mutter, warning
9
9
import os.path
10
10
import tempfile
11
11
import shutil
12
12
import errno
13
13
 
 
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
 
14
21
class UnrelatedBranches(BzrCommandError):
15
22
    def __init__(self):
16
23
        msg = "Branches have no common ancestor, and no base revision"\
19
26
 
20
27
 
21
28
class MergeConflictHandler(ExceptionConflictHandler):
22
 
    """Handle conflicts encountered while merging"""
 
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
    """
23
35
    def __init__(self, dir, ignore_zero=False):
24
36
        ExceptionConflictHandler.__init__(self, dir)
25
37
        self.conflicts = 0
36
48
            d_file.write(line)
37
49
        os.chmod(dest, 0777 & os.stat(source).st_mode)
38
50
 
 
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
 
39
60
    def add_suffix(self, name, suffix, last_new_name=None):
40
61
        """Rename a file to append a suffix.  If the new name exists, the
41
62
        suffix is added repeatedly until a non-existant name is found
60
81
        self.conflicts += 1
61
82
        
62
83
 
63
 
    def merge_conflict(self, new_file, this_path, base_path, other_path):
 
84
    def merge_conflict(self, new_file, this_path, base_lines, other_lines):
64
85
        """
65
86
        Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER.  The
66
87
        main file will be a version with diff3 conflicts.
70
91
        :param other_path: Path to the file text for the OTHER tree
71
92
        """
72
93
        self.add_suffix(this_path, ".THIS")
73
 
        self.copy(base_path, this_path+".BASE")
74
 
        self.copy(other_path, this_path+".OTHER")
 
94
        self.dump(base_lines, this_path+".BASE")
 
95
        self.dump(other_lines, this_path+".OTHER")
75
96
        os.rename(new_file, this_path)
76
97
        self.conflict("Diff3 conflict encountered in %s" % this_path)
77
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
 
78
105
    def target_exists(self, entry, target, old_path):
79
106
        """Handle the case when the target file or dir exists"""
80
107
        moved_path = self.add_suffix(target, ".moved")
90
117
        if not self.ignore_zero:
91
118
            print "%d conflicts encountered.\n" % self.conflicts
92
119
            
93
 
class SourceFile(object):
94
 
    def __init__(self, path, id, present=None, isdir=None):
95
 
        self.path = path
96
 
        self.id = id
97
 
        self.present = present
98
 
        self.isdir = isdir
99
 
        self.interesting = True
100
 
 
101
 
    def __repr__(self):
102
 
        return "SourceFile(%s, %s)" % (self.path, self.id)
103
 
 
104
120
def get_tree(treespec, temp_root, label):
105
121
    location, revno = treespec
106
122
    branch = find_branch(location)
115
131
    return branch, MergeTree(base_tree, temp_path)
116
132
 
117
133
 
118
 
def abspath(tree, file_id):
119
 
    path = tree.inventory.id2path(file_id)
120
 
    if path == "":
121
 
        return "./."
122
 
    return "./" + path
123
 
 
124
134
def file_exists(tree, file_id):
125
135
    return tree.has_filename(tree.id2path(file_id))
126
136
    
127
 
def inventory_map(tree):
128
 
    inventory = {}
129
 
    for file_id in tree.inventory:
130
 
        path = abspath(tree, file_id)
131
 
        inventory[path] = SourceFile(path, file_id)
132
 
    return inventory
133
 
 
134
137
 
135
138
class MergeTree(object):
136
139
    def __init__(self, tree, tempdir):
139
142
            self.root = tree.basedir
140
143
        else:
141
144
            self.root = None
142
 
        self.inventory = inventory_map(tree)
143
145
        self.tree = tree
144
146
        self.tempdir = tempdir
145
147
        os.mkdir(os.path.join(self.tempdir, "texts"))
146
148
        self.cached = {}
147
149
 
 
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
 
148
168
    def readonly_path(self, id):
149
169
        if id not in self.tree:
150
170
            return None
165
185
 
166
186
def merge(other_revision, base_revision,
167
187
          check_clean=True, ignore_zero=False,
168
 
          this_dir=None):
 
188
          this_dir=None, backup_files=False, merge_type=ApplyMerge3,
 
189
          file_list=None):
169
190
    """Merge changes into a tree.
170
191
 
171
192
    base_revision
200
221
                raise UnrelatedBranches()
201
222
            base_revision = ['.', base_revno]
202
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)
203
240
        merge_inner(this_branch, other_tree, base_tree, tempdir, 
204
 
                    ignore_zero=ignore_zero)
 
241
                    ignore_zero=ignore_zero, backup_files=backup_files, 
 
242
                    merge_type=merge_type, interesting_ids=interesting_ids)
205
243
    finally:
206
244
        shutil.rmtree(tempdir)
207
245
 
208
246
 
209
 
def generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b):
210
 
    """Generate a changeset, using the text_id to mark really-changed files.
211
 
    This permits blazing comparisons when text_ids are present.  It also
212
 
    disables metadata comparison for files with identical texts.
 
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.
213
258
    """ 
214
 
    for file_id in tree_a.tree.inventory:
215
 
        if file_id not in tree_b.tree.inventory:
216
 
            continue
217
 
        entry_a = tree_a.tree.inventory[file_id]
218
 
        entry_b = tree_b.tree.inventory[file_id]
219
 
        if (entry_a.kind, entry_b.kind) != ("file", "file"):
220
 
            continue
221
 
        if None in (entry_a.text_id, entry_b.text_id):
222
 
            continue
223
 
        if entry_a.text_id != entry_b.text_id:
224
 
            continue
225
 
        inventory_a[abspath(tree_a.tree, file_id)].interesting = False
226
 
        inventory_b[abspath(tree_b.tree, file_id)].interesting = False
227
 
    cset =  generate_changeset(tree_a, tree_b, inventory_a, inventory_b)
 
259
    cset =  generate_changeset(tree_a, tree_b, interesting_ids)
228
260
    for entry in cset.entries.itervalues():
229
261
        entry.metadata_change = None
230
262
    return cset
231
263
 
232
264
 
233
265
def merge_inner(this_branch, other_tree, base_tree, tempdir, 
234
 
                ignore_zero=False):
 
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
 
235
275
    this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
236
276
 
237
277
    def get_inventory(tree):
238
 
        return tree.inventory
 
278
        return tree.tree.inventory
239
279
 
240
280
    inv_changes = merge_flex(this_tree, base_tree, other_tree,
241
281
                             generate_cset_optimized, get_inventory,
242
282
                             MergeConflictHandler(base_tree.root,
243
 
                                                  ignore_zero=ignore_zero))
 
283
                                                  ignore_zero=ignore_zero),
 
284
                             merge_factory=merge_factory, 
 
285
                             interesting_ids=interesting_ids)
244
286
 
245
287
    adjust_ids = []
246
288
    for id, path in inv_changes.iteritems():
248
290
            if path == '.':
249
291
                path = ''
250
292
            else:
251
 
                assert path.startswith('./')
 
293
                assert path.startswith('./'), "path is %s" % path
252
294
            path = path[2:]
253
295
        adjust_ids.append((path, id))
254
 
    this_branch.set_inventory(regen_inventory(this_branch, this_tree.root, adjust_ids))
 
296
    if len(adjust_ids) > 0:
 
297
        this_branch.set_inventory(regen_inventory(this_branch, this_tree.root,
 
298
                                                  adjust_ids))
255
299
 
256
300
 
257
301
def regen_inventory(this_branch, root, new_entries):
258
302
    old_entries = this_branch.read_working_inventory()
259
303
    new_inventory = {}
260
304
    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
        
261
320
    for file_id in old_entries:
262
321
        entry = old_entries[file_id]
263
 
        path = old_entries.id2path(file_id)
 
322
        path = id2path(file_id)
264
323
        new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
265
324
        by_path[path] = file_id
266
325
    
294
353
    assert len(new_inventory_list) == len(old_entries) + insertions - deletions
295
354
    new_inventory_list.sort()
296
355
    return new_inventory_list
 
356
 
 
357
merge_types = {     "merge3": (ApplyMerge3, "Native diff3-style merge"), 
 
358
                     "diff3": (Diff3Merge,  "Merge using external diff3")
 
359
              }
 
360