← 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
  • Date: 2005-08-26 12:38:57 UTC
  • mfrom: (974.1.45)
  • mto: (1185.3.4)
  • mto: This revision was merged to the branch mainline in revision 1178.
  • Revision ID: abentley@panoramicfeedback.com-20050826123857-06b8856e0fa2d374
Fixed ancestor-picking when -r is specified

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
10
10
import tempfile
11
11
import shutil
12
12
import errno
 
13
from fetch import greedy_fetch
13
14
 
14
15
 
15
16
# comments from abentley on irc: merge happens in two stages, each
48
49
            d_file.write(line)
49
50
        os.chmod(dest, 0777 & os.stat(source).st_mode)
50
51
 
 
52
    def dump(self, lines, dest):
 
53
        """Copy the text and mode of a file
 
54
        :param source: The path of the file to copy
 
55
        :param dest: The distination file to create
 
56
        """
 
57
        d_file = file(dest, "wb")
 
58
        for line in lines:
 
59
            d_file.write(line)
 
60
 
51
61
    def add_suffix(self, name, suffix, last_new_name=None):
52
62
        """Rename a file to append a suffix.  If the new name exists, the
53
63
        suffix is added repeatedly until a non-existant name is found
72
82
        self.conflicts += 1
73
83
        
74
84
 
75
 
    def merge_conflict(self, new_file, this_path, base_path, other_path):
 
85
    def merge_conflict(self, new_file, this_path, base_lines, other_lines):
76
86
        """
77
87
        Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER.  The
78
88
        main file will be a version with diff3 conflicts.
82
92
        :param other_path: Path to the file text for the OTHER tree
83
93
        """
84
94
        self.add_suffix(this_path, ".THIS")
85
 
        self.copy(base_path, this_path+".BASE")
86
 
        self.copy(other_path, this_path+".OTHER")
 
95
        self.dump(base_lines, this_path+".BASE")
 
96
        self.dump(other_lines, this_path+".OTHER")
87
97
        os.rename(new_file, this_path)
88
98
        self.conflict("Diff3 conflict encountered in %s" % this_path)
89
99
 
108
118
        if not self.ignore_zero:
109
119
            print "%d conflicts encountered.\n" % self.conflicts
110
120
            
111
 
class SourceFile(object):
112
 
    def __init__(self, path, id, present=None, isdir=None):
113
 
        self.path = path
114
 
        self.id = id
115
 
        self.present = present
116
 
        self.isdir = isdir
117
 
        self.interesting = True
118
 
 
119
 
    def __repr__(self):
120
 
        return "SourceFile(%s, %s)" % (self.path, self.id)
121
 
 
122
 
def get_tree(treespec, temp_root, label):
 
121
def get_tree(treespec, temp_root, label, local_branch=None):
123
122
    location, revno = treespec
124
123
    branch = find_branch(location)
125
124
    if revno is None:
 
125
        revision = None
 
126
    elif revno == -1:
 
127
        revision = branch.last_patch()
 
128
    else:
 
129
        revision = branch.lookup_revision(revno)
 
130
    return branch, get_revid_tree(branch, revision, temp_root, label,
 
131
                                  local_branch)
 
132
 
 
133
def get_revid_tree(branch, revision, temp_root, label, local_branch):
 
134
    if revision is None:
126
135
        base_tree = branch.working_tree()
127
 
    elif revno == -1:
128
 
        base_tree = branch.basis_tree()
129
136
    else:
130
 
        base_tree = branch.revision_tree(branch.lookup_revision(revno))
 
137
        if local_branch is not None:
 
138
            greedy_fetch(local_branch, branch, revision)
 
139
            base_tree = local_branch.revision_tree(revision)
 
140
        else:
 
141
            base_tree = branch.revision_tree(revision)
131
142
    temp_path = os.path.join(temp_root, label)
132
143
    os.mkdir(temp_path)
133
 
    return branch, MergeTree(base_tree, temp_path)
134
 
 
135
 
 
136
 
def abspath(tree, file_id):
137
 
    path = tree.inventory.id2path(file_id)
138
 
    if path == "":
139
 
        return "./."
140
 
    return "./" + path
 
144
    return MergeTree(base_tree, temp_path)
 
145
 
141
146
 
142
147
def file_exists(tree, file_id):
143
148
    return tree.has_filename(tree.id2path(file_id))
144
149
    
145
 
def inventory_map(tree):
146
 
    inventory = {}
147
 
    for file_id in tree.inventory:
148
 
        path = abspath(tree, file_id)
149
 
        inventory[path] = SourceFile(path, file_id)
150
 
    return inventory
151
 
 
152
150
 
153
151
class MergeTree(object):
154
152
    def __init__(self, tree, tempdir):
157
155
            self.root = tree.basedir
158
156
        else:
159
157
            self.root = None
160
 
        self.inventory = inventory_map(tree)
161
158
        self.tree = tree
162
159
        self.tempdir = tempdir
163
160
        os.mkdir(os.path.join(self.tempdir, "texts"))
164
161
        self.cached = {}
165
162
 
 
163
    def __iter__(self):
 
164
        return self.tree.__iter__()
 
165
 
166
166
    def __contains__(self, file_id):
167
 
        return id in self.tree
 
167
        return file_id in self.tree
 
168
 
 
169
    def get_file(self, file_id):
 
170
        return self.tree.get_file(file_id)
168
171
 
169
172
    def get_file_sha1(self, id):
170
173
        return self.tree.get_file_sha1(id)
171
174
 
 
175
    def id2path(self, file_id):
 
176
        return self.tree.id2path(file_id)
 
177
 
 
178
    def has_id(self, file_id):
 
179
        return self.tree.has_id(file_id)
 
180
 
172
181
    def readonly_path(self, id):
173
182
        if id not in self.tree:
174
183
            return None
202
211
    check_clean
203
212
        If true, this_dir must have no uncommitted changes before the
204
213
        merge begins.
 
214
    all available ancestors of other_revision and base_revision are
 
215
    automatically pulled into the branch.
205
216
    """
 
217
    from bzrlib.revision import common_ancestor, is_ancestor
 
218
    from bzrlib.revision import MultipleRevisionSources
 
219
    from bzrlib.errors import NoSuchRevision
206
220
    tempdir = tempfile.mkdtemp(prefix="bzr-")
207
221
    try:
208
222
        if this_dir is None:
209
223
            this_dir = '.'
210
224
        this_branch = find_branch(this_dir)
 
225
        this_rev_id = this_branch.last_patch()
 
226
        if this_rev_id is None:
 
227
            raise BzrCommandError("This branch has no commits")
211
228
        if check_clean:
212
229
            changes = compare_trees(this_branch.working_tree(), 
213
230
                                    this_branch.basis_tree(), False)
214
231
            if changes.has_changed():
215
232
                raise BzrCommandError("Working tree has uncommitted changes.")
216
 
        other_branch, other_tree = get_tree(other_revision, tempdir, "other")
 
233
        other_branch, other_tree = get_tree(other_revision, tempdir, "other",
 
234
                                            this_branch)
 
235
        if other_revision[1] == -1:
 
236
            other_rev_id = other_branch.last_patch()
 
237
            other_basis = other_rev_id
 
238
        elif other_revision[1] is not None:
 
239
            other_rev_id = other_branch.lookup_revision(other_revision[1])
 
240
            other_basis = other_rev_id
 
241
        else:
 
242
            other_rev_id = None
 
243
            other_basis = other_branch.last_patch()
217
244
        if base_revision == [None, None]:
218
 
            if other_revision[1] == -1:
219
 
                o_revno = None
220
 
            else:
221
 
                o_revno = other_revision[1]
222
 
            base_revno = this_branch.common_ancestor(other_branch, 
223
 
                                                     other_revno=o_revno)[0]
224
 
            if base_revno is None:
 
245
            base_rev_id = common_ancestor(this_rev_id, other_basis, 
 
246
                                          this_branch)
 
247
            if base_rev_id is None:
225
248
                raise UnrelatedBranches()
226
 
            base_revision = ['.', base_revno]
227
 
        base_branch, base_tree = get_tree(base_revision, tempdir, "base")
 
249
            base_tree = get_revid_tree(this_branch, base_rev_id, tempdir, 
 
250
                                       "base", None)
 
251
            base_is_ancestor = True
 
252
        else:
 
253
            base_branch, base_tree = get_tree(base_revision, tempdir, "base")
 
254
            if base_revision[1] == -1:
 
255
                base_rev_id = base_branch.last_patch()
 
256
            elif base_revision[1] is None:
 
257
                base_rev_id = None
 
258
            else:
 
259
                base_rev_id = base_branch.lookup_revision(base_revision[1])
 
260
            if base_rev_id is not None:
 
261
                base_is_ancestor = is_ancestor(this_rev_id, base_rev_id, 
 
262
                                               MultipleRevisionSources(
 
263
                                               this_branch, 
 
264
                                               base_branch))
 
265
            else:
 
266
                base_is_ancestor = False
228
267
        if file_list is None:
229
268
            interesting_ids = None
230
269
        else:
244
283
        merge_inner(this_branch, other_tree, base_tree, tempdir, 
245
284
                    ignore_zero=ignore_zero, backup_files=backup_files, 
246
285
                    merge_type=merge_type, interesting_ids=interesting_ids)
 
286
        if base_is_ancestor and other_rev_id is not None:
 
287
            this_branch.add_pending_merge(other_rev_id)
247
288
    finally:
248
289
        shutil.rmtree(tempdir)
249
290
 
256
297
             source_file.interesting = source_file.id in interesting_ids
257
298
 
258
299
 
259
 
def generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b,
260
 
                            interesting_ids=None):
 
300
def generate_cset_optimized(tree_a, tree_b, interesting_ids=None):
261
301
    """Generate a changeset.  If interesting_ids is supplied, only changes
262
302
    to those files will be shown.  Metadata changes are stripped.
263
303
    """ 
264
 
    if interesting_ids is not None:
265
 
        set_interesting(inventory_a, inventory_b, interesting_ids)
266
 
    cset =  generate_changeset(tree_a, tree_b, inventory_a, inventory_b)
 
304
    cset =  generate_changeset(tree_a, tree_b, interesting_ids)
267
305
    for entry in cset.entries.itervalues():
268
306
        entry.metadata_change = None
269
307
    return cset
273
311
                ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
274
312
                interesting_ids=None):
275
313
 
276
 
    def merge_factory(base_file, other_file):
277
 
        contents_change = merge_type(base_file, other_file)
 
314
    def merge_factory(file_id, base, other):
 
315
        contents_change = merge_type(file_id, base, other)
278
316
        if backup_files:
279
317
            contents_change = BackupBeforeChange(contents_change)
280
318
        return contents_change
281
 
    
282
 
    def generate_cset(tree_a, tree_b, inventory_a, inventory_b):
283
 
        return generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b,
284
 
                                       interesting_ids)
285
319
 
286
320
    this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
287
321
 
288
322
    def get_inventory(tree):
289
 
        return tree.inventory
 
323
        return tree.tree.inventory
290
324
 
291
325
    inv_changes = merge_flex(this_tree, base_tree, other_tree,
292
 
                             generate_cset, get_inventory,
 
326
                             generate_cset_optimized, get_inventory,
293
327
                             MergeConflictHandler(base_tree.root,
294
328
                                                  ignore_zero=ignore_zero),
295
 
                             merge_factory=merge_factory)
 
329
                             merge_factory=merge_factory, 
 
330
                             interesting_ids=interesting_ids)
296
331
 
297
332
    adjust_ids = []
298
333
    for id, path in inv_changes.iteritems():
300
335
            if path == '.':
301
336
                path = ''
302
337
            else:
303
 
                assert path.startswith('./')
 
338
                assert path.startswith('./'), "path is %s" % path
304
339
            path = path[2:]
305
340
        adjust_ids.append((path, id))
306
341
    if len(adjust_ids) > 0:
312
347
    old_entries = this_branch.read_working_inventory()
313
348
    new_inventory = {}
314
349
    by_path = {}
 
350
    new_entries_map = {} 
 
351
    for path, file_id in new_entries:
 
352
        if path is None:
 
353
            continue
 
354
        new_entries_map[file_id] = path
 
355
 
 
356
    def id2path(file_id):
 
357
        path = new_entries_map.get(file_id)
 
358
        if path is not None:
 
359
            return path
 
360
        entry = old_entries[file_id]
 
361
        if entry.parent_id is None:
 
362
            return entry.name
 
363
        return os.path.join(id2path(entry.parent_id), entry.name)
 
364
        
315
365
    for file_id in old_entries:
316
366
        entry = old_entries[file_id]
317
 
        path = old_entries.id2path(file_id)
 
367
        path = id2path(file_id)
318
368
        new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
319
369
        by_path[path] = file_id
320
370