/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-05-17 07:01:47 UTC
  • Revision ID: mbp@sourcefrog.net-20050517070147-c38da17418ea6711
- Add patch to give symlink support

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
 
from merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
 
1
from merge_core import merge_flex
2
2
from changeset import generate_changeset, ExceptionConflictHandler
3
 
from changeset import Inventory, Diff3Merge
4
 
from bzrlib import find_branch
 
3
from changeset import Inventory
 
4
from bzrlib import Branch
5
5
import bzrlib.osutils
6
 
from bzrlib.errors import BzrCommandError
7
 
from bzrlib.delta import compare_trees
8
 
from trace import mutter, warning
 
6
from trace import mutter
9
7
import os.path
10
8
import tempfile
11
9
import shutil
12
10
import errno
13
11
 
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
 
 
21
12
class MergeConflictHandler(ExceptionConflictHandler):
22
13
    """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
 
 
28
14
    def copy(self, source, dest):
29
15
        """Copy the text and mode of a file
30
16
        :param source: The path of the file to copy
49
35
        new_name = last_new_name+suffix
50
36
        try:
51
37
            os.rename(name, new_name)
52
 
            return new_name
53
38
        except OSError, e:
54
39
            if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
55
40
                raise
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
 
        
 
41
            self.add_suffix(name, suffix, last_new_name=new_name)
62
42
 
63
43
    def merge_conflict(self, new_file, this_path, base_path, other_path):
64
44
        """
73
53
        self.copy(base_path, this_path+".BASE")
74
54
        self.copy(other_path, this_path+".OTHER")
75
55
        os.rename(new_file, this_path)
76
 
        self.conflict("Diff3 conflict encountered in %s" % this_path)
77
56
 
78
57
    def target_exists(self, entry, target, old_path):
79
58
        """Handle the case when the target file or dir exists"""
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
 
59
        self.add_suffix(target, ".moved")
92
60
            
93
 
class SourceFile(object):
 
61
class SourceFile:
94
62
    def __init__(self, path, id, present=None, isdir=None):
95
63
        self.path = path
96
64
        self.id = id
102
70
        return "SourceFile(%s, %s)" % (self.path, self.id)
103
71
 
104
72
def get_tree(treespec, temp_root, label):
105
 
    location, revno = treespec
106
 
    branch = find_branch(location)
 
73
    dir, revno = treespec
 
74
    branch = Branch(dir)
107
75
    if revno is None:
108
76
        base_tree = branch.working_tree()
109
77
    elif revno == -1:
112
80
        base_tree = branch.revision_tree(branch.lookup_revision(revno))
113
81
    temp_path = os.path.join(temp_root, label)
114
82
    os.mkdir(temp_path)
115
 
    return branch, MergeTree(base_tree, temp_path)
 
83
    return MergeTree(base_tree, temp_path)
116
84
 
117
85
 
118
86
def abspath(tree, file_id):
127
95
def inventory_map(tree):
128
96
    inventory = {}
129
97
    for file_id in tree.inventory:
 
98
        if not file_exists(tree, file_id):
 
99
            continue
130
100
        path = abspath(tree, file_id)
131
101
        inventory[path] = SourceFile(path, file_id)
132
102
    return inventory
146
116
        self.cached = {}
147
117
 
148
118
    def readonly_path(self, id):
149
 
        if id not in self.tree:
150
 
            return None
151
119
        if self.root is not None:
152
120
            return self.tree.abspath(self.tree.id2path(id))
153
121
        else:
161
129
                self.cached[id] = path
162
130
            return self.cached[id]
163
131
 
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
 
    """
 
132
def merge(other_revision, base_revision):
182
133
    tempdir = tempfile.mkdtemp(prefix="bzr-")
183
134
    try:
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)
 
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)
223
139
    finally:
224
140
        shutil.rmtree(tempdir)
225
141
 
226
142
 
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
 
    """
 
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
    """ 
238
148
    for file_id in tree_a.tree.inventory:
239
149
        if file_id not in tree_b.tree.inventory:
240
150
            continue
248
158
            continue
249
159
        inventory_a[abspath(tree_a.tree, file_id)].interesting = False
250
160
        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)
264
161
    cset =  generate_changeset(tree_a, tree_b, inventory_a, inventory_b)
265
162
    for entry in cset.entries.itervalues():
266
163
        entry.metadata_change = None
267
164
    return cset
268
165
 
269
166
 
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]
 
167
def merge_inner(this_branch, other_tree, base_tree, tempdir):
 
168
    this_tree = get_tree(('.', None), tempdir, "this")
285
169
 
286
170
    def get_inventory(tree):
287
171
        return tree.inventory
288
172
 
289
173
    inv_changes = merge_flex(this_tree, base_tree, other_tree,
290
 
                             generate_cset, get_inventory,
291
 
                             MergeConflictHandler(base_tree.root,
292
 
                                                  ignore_zero=ignore_zero),
293
 
                             merge_factory=merge_factory)
 
174
                             generate_cset_optimized, get_inventory,
 
175
                             MergeConflictHandler(base_tree.root))
294
176
 
295
177
    adjust_ids = []
296
178
    for id, path in inv_changes.iteritems():
344
226
    assert len(new_inventory_list) == len(old_entries) + insertions - deletions
345
227
    new_inventory_list.sort()
346
228
    return new_inventory_list
347
 
 
348
 
merge_types = {     "merge3": (ApplyMerge3, "Native diff3-style merge"), 
349
 
                     "diff3": (Diff3Merge,  "Merge using external diff3")
350
 
              }
351