/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Martin Pool
  • Date: 2005-08-04 22:04:40 UTC
  • Revision ID: mbp@sourcefrog.net-20050804220440-99562df8151d1ac5
- add pending merge from aaron

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
 
from merge_core import merge_flex
 
1
from merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
2
2
from changeset import generate_changeset, ExceptionConflictHandler
3
 
from changeset import Inventory
4
 
from bzrlib import Branch
 
3
from changeset import Inventory, Diff3Merge
 
4
from bzrlib import find_branch
5
5
import bzrlib.osutils
6
 
from trace import mutter
 
6
from bzrlib.errors import BzrCommandError
 
7
from bzrlib.delta import compare_trees
 
8
from trace import mutter, warning
7
9
import os.path
8
10
import tempfile
9
11
import shutil
10
12
import errno
11
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
 
 
20
 
12
21
class MergeConflictHandler(ExceptionConflictHandler):
13
22
    """Handle conflicts encountered while merging"""
 
23
    def __init__(self, dir, ignore_zero=False):
 
24
        ExceptionConflictHandler.__init__(self, dir)
 
25
        self.conflicts = 0
 
26
        self.ignore_zero = ignore_zero
 
27
 
14
28
    def copy(self, source, dest):
15
29
        """Copy the text and mode of a file
16
30
        :param source: The path of the file to copy
35
49
        new_name = last_new_name+suffix
36
50
        try:
37
51
            os.rename(name, new_name)
 
52
            return new_name
38
53
        except OSError, e:
39
54
            if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
40
55
                raise
41
 
            self.add_suffix(name, suffix, last_new_name=new_name)
 
56
            return self.add_suffix(name, suffix, last_new_name=new_name)
 
57
 
 
58
    def conflict(self, text):
 
59
        warning(text)
 
60
        self.conflicts += 1
 
61
        
42
62
 
43
63
    def merge_conflict(self, new_file, this_path, base_path, other_path):
44
64
        """
53
73
        self.copy(base_path, this_path+".BASE")
54
74
        self.copy(other_path, this_path+".OTHER")
55
75
        os.rename(new_file, this_path)
 
76
        self.conflict("Diff3 conflict encountered in %s" % this_path)
56
77
 
57
78
    def target_exists(self, entry, target, old_path):
58
79
        """Handle the case when the target file or dir exists"""
59
 
        self.add_suffix(target, ".moved")
 
80
        moved_path = self.add_suffix(target, ".moved")
 
81
        self.conflict("Moved existing %s to %s" % (target, moved_path))
 
82
 
 
83
    def rmdir_non_empty(self, filename):
 
84
        """Handle the case where the dir to be removed still has contents"""
 
85
        self.conflict("Directory %s not removed because it is not empty"\
 
86
            % filename)
 
87
        return "skip"
 
88
 
 
89
    def finalize(self):
 
90
        if not self.ignore_zero:
 
91
            print "%d conflicts encountered.\n" % self.conflicts
60
92
            
61
93
class SourceFile(object):
62
94
    def __init__(self, path, id, present=None, isdir=None):
70
102
        return "SourceFile(%s, %s)" % (self.path, self.id)
71
103
 
72
104
def get_tree(treespec, temp_root, label):
73
 
    dir, revno = treespec
74
 
    branch = Branch(dir)
 
105
    location, revno = treespec
 
106
    branch = find_branch(location)
75
107
    if revno is None:
76
108
        base_tree = branch.working_tree()
77
109
    elif revno == -1:
80
112
        base_tree = branch.revision_tree(branch.lookup_revision(revno))
81
113
    temp_path = os.path.join(temp_root, label)
82
114
    os.mkdir(temp_path)
83
 
    return MergeTree(base_tree, temp_path)
 
115
    return branch, MergeTree(base_tree, temp_path)
84
116
 
85
117
 
86
118
def abspath(tree, file_id):
95
127
def inventory_map(tree):
96
128
    inventory = {}
97
129
    for file_id in tree.inventory:
98
 
        if not file_exists(tree, file_id):
99
 
            continue
100
130
        path = abspath(tree, file_id)
101
131
        inventory[path] = SourceFile(path, file_id)
102
132
    return inventory
116
146
        self.cached = {}
117
147
 
118
148
    def readonly_path(self, id):
 
149
        if id not in self.tree:
 
150
            return None
119
151
        if self.root is not None:
120
152
            return self.tree.abspath(self.tree.id2path(id))
121
153
        else:
129
161
                self.cached[id] = path
130
162
            return self.cached[id]
131
163
 
132
 
def merge(other_revision, base_revision):
 
164
 
 
165
 
 
166
def merge(other_revision, base_revision,
 
167
          check_clean=True, ignore_zero=False,
 
168
          this_dir=None, backup_files=False, merge_type=ApplyMerge3,
 
169
          file_list=None):
 
170
    """Merge changes into a tree.
 
171
 
 
172
    base_revision
 
173
        Base for three-way merge.
 
174
    other_revision
 
175
        Other revision for three-way merge.
 
176
    this_dir
 
177
        Directory to merge changes into; '.' by default.
 
178
    check_clean
 
179
        If true, this_dir must have no uncommitted changes before the
 
180
        merge begins.
 
181
    """
133
182
    tempdir = tempfile.mkdtemp(prefix="bzr-")
134
183
    try:
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)
 
184
        if this_dir is None:
 
185
            this_dir = '.'
 
186
        this_branch = find_branch(this_dir)
 
187
        if check_clean:
 
188
            changes = compare_trees(this_branch.working_tree(), 
 
189
                                    this_branch.basis_tree(), False)
 
190
            if changes.has_changed():
 
191
                raise BzrCommandError("Working tree has uncommitted changes.")
 
192
        other_branch, other_tree = get_tree(other_revision, tempdir, "other")
 
193
        if base_revision == [None, None]:
 
194
            if other_revision[1] == -1:
 
195
                o_revno = None
 
196
            else:
 
197
                o_revno = other_revision[1]
 
198
            base_revno = this_branch.common_ancestor(other_branch, 
 
199
                                                     other_revno=o_revno)[0]
 
200
            if base_revno is None:
 
201
                raise UnrelatedBranches()
 
202
            base_revision = ['.', base_revno]
 
203
        base_branch, base_tree = get_tree(base_revision, tempdir, "base")
 
204
        if file_list is None:
 
205
            interesting_ids = None
 
206
        else:
 
207
            interesting_ids = set()
 
208
            this_tree = this_branch.working_tree()
 
209
            for fname in file_list:
 
210
                path = this_branch.relpath(fname)
 
211
                found_id = False
 
212
                for tree in (this_tree, base_tree.tree, other_tree.tree):
 
213
                    file_id = tree.inventory.path2id(path)
 
214
                    if file_id is not None:
 
215
                        interesting_ids.add(file_id)
 
216
                        found_id = True
 
217
                if not found_id:
 
218
                    raise BzrCommandError("%s is not a source file in any"
 
219
                                          " tree." % fname)
 
220
        merge_inner(this_branch, other_tree, base_tree, tempdir, 
 
221
                    ignore_zero=ignore_zero, backup_files=backup_files, 
 
222
                    merge_type=merge_type, interesting_ids=interesting_ids)
139
223
    finally:
140
224
        shutil.rmtree(tempdir)
141
225
 
142
226
 
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.
147
 
    """ 
 
227
def set_interesting(inventory_a, inventory_b, interesting_ids):
 
228
    """Mark files whose ids are in interesting_ids as interesting
 
229
    """
 
230
    for inventory in (inventory_a, inventory_b):
 
231
        for path, source_file in inventory.iteritems():
 
232
             source_file.interesting = source_file.id in interesting_ids
 
233
 
 
234
 
 
235
def set_optimized(tree_a, tree_b, inventory_a, inventory_b):
 
236
    """Mark files that have changed texts as interesting
 
237
    """
148
238
    for file_id in tree_a.tree.inventory:
149
239
        if file_id not in tree_b.tree.inventory:
150
240
            continue
158
248
            continue
159
249
        inventory_a[abspath(tree_a.tree, file_id)].interesting = False
160
250
        inventory_b[abspath(tree_b.tree, file_id)].interesting = False
 
251
 
 
252
 
 
253
def generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b,
 
254
                            interesting_ids=None):
 
255
    """Generate a changeset, with preprocessing to select interesting files.
 
256
    using the text_id to mark really-changed files.
 
257
    This permits blazing comparisons when text_ids are present.  It also
 
258
    disables metadata comparison for files with identical texts.
 
259
    """ 
 
260
    if interesting_ids is None:
 
261
        set_optimized(tree_a, tree_b, inventory_a, inventory_b)
 
262
    else:
 
263
        set_interesting(inventory_a, inventory_b, interesting_ids)
161
264
    cset =  generate_changeset(tree_a, tree_b, inventory_a, inventory_b)
162
265
    for entry in cset.entries.itervalues():
163
266
        entry.metadata_change = None
164
267
    return cset
165
268
 
166
269
 
167
 
def merge_inner(this_branch, other_tree, base_tree, tempdir):
168
 
    this_tree = get_tree(('.', None), tempdir, "this")
 
270
def merge_inner(this_branch, other_tree, base_tree, tempdir, 
 
271
                ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
 
272
                interesting_ids=None):
 
273
 
 
274
    def merge_factory(base_file, other_file):
 
275
        contents_change = merge_type(base_file, other_file)
 
276
        if backup_files:
 
277
            contents_change = BackupBeforeChange(contents_change)
 
278
        return contents_change
 
279
    
 
280
    def generate_cset(tree_a, tree_b, inventory_a, inventory_b):
 
281
        return generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b,
 
282
                                       interesting_ids)
 
283
 
 
284
    this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
169
285
 
170
286
    def get_inventory(tree):
171
287
        return tree.inventory
172
288
 
173
289
    inv_changes = merge_flex(this_tree, base_tree, other_tree,
174
 
                             generate_cset_optimized, get_inventory,
175
 
                             MergeConflictHandler(base_tree.root))
 
290
                             generate_cset, get_inventory,
 
291
                             MergeConflictHandler(base_tree.root,
 
292
                                                  ignore_zero=ignore_zero),
 
293
                             merge_factory=merge_factory)
176
294
 
177
295
    adjust_ids = []
178
296
    for id, path in inv_changes.iteritems():
226
344
    assert len(new_inventory_list) == len(old_entries) + insertions - deletions
227
345
    new_inventory_list.sort()
228
346
    return new_inventory_list
 
347
 
 
348
merge_types = {     "merge3": (ApplyMerge3, "Native diff3-style merge"), 
 
349
                     "diff3": (Diff3Merge,  "Merge using external diff3")
 
350
              }
 
351