← 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-07-15 13:43:54 UTC
  • mto: This revision was merged to the branch mainline in revision 923.
  • Revision ID: abentley@panoramicfeedback.com-20050715134354-78f2bca607acb415
Fixed log -v (mostly)

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