← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Robert Collins
  • Date: 2005-10-11 08:31:29 UTC
  • Revision ID: robertc@lifelesslap.robertcollins.net-20051011083129-fa720bc6cd6c039f
inline and simplify branch.find_branch_root, it should just try to create a branch at each step, which is simpler than probing for a specific dir and has less round trips.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
import os.path
 
18
import os
19
19
import tempfile
20
20
import shutil
21
21
import errno
22
 
from fetch import greedy_fetch
23
22
 
24
23
import bzrlib.osutils
25
24
import bzrlib.revision
26
25
from bzrlib.merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
27
26
from bzrlib.changeset import generate_changeset, ExceptionConflictHandler
28
 
from bzrlib.changeset import Inventory, Diff3Merge
29
 
from bzrlib.branch import find_branch
30
 
from bzrlib.errors import BzrCommandError, UnrelatedBranches
 
27
from bzrlib.changeset import Inventory, Diff3Merge, ReplaceContents
 
28
from bzrlib.branch import Branch
 
29
from bzrlib.errors import BzrCommandError, UnrelatedBranches, NoCommonAncestor
 
30
from bzrlib.errors import NoCommits
31
31
from bzrlib.delta import compare_trees
32
 
from bzrlib.trace import mutter, warning
33
 
from bzrlib.fetch import greedy_fetch
 
32
from bzrlib.trace import mutter, warning, note
 
33
from bzrlib.fetch import greedy_fetch, fetch
34
34
from bzrlib.revision import is_ancestor
 
35
from bzrlib.osutils import rename
 
36
from bzrlib.revision import common_ancestor, MultipleRevisionSources
 
37
from bzrlib.errors import NoSuchRevision
 
38
 
 
39
# TODO: build_working_dir can be built on something simpler than merge()
 
40
 
 
41
# FIXME: merge() parameters seem oriented towards the command line
 
42
# NOTABUG: merge is a helper for commandline functions.  merge_inner is the
 
43
#          the core functionality.
35
44
 
36
45
# comments from abentley on irc: merge happens in two stages, each
37
46
# of which generates a changeset object
46
55
    conflict that are not explicitly handled cause an exception and
47
56
    terminate the merge.
48
57
    """
49
 
    def __init__(self, dir, ignore_zero=False):
50
 
        ExceptionConflictHandler.__init__(self, dir)
 
58
    def __init__(self, this_tree, base_tree, other_tree, ignore_zero=False):
 
59
        ExceptionConflictHandler.__init__(self)
51
60
        self.conflicts = 0
52
61
        self.ignore_zero = ignore_zero
 
62
        self.this_tree = this_tree
 
63
        self.base_tree = base_tree
 
64
        self.other_tree = other_tree
53
65
 
54
66
    def copy(self, source, dest):
55
67
        """Copy the text and mode of a file
83
95
            last_new_name = name
84
96
        new_name = last_new_name+suffix
85
97
        try:
86
 
            os.rename(name, new_name)
 
98
            rename(name, new_name)
87
99
            return new_name
88
100
        except OSError, e:
89
101
            if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
107
119
        self.add_suffix(this_path, ".THIS")
108
120
        self.dump(base_lines, this_path+".BASE")
109
121
        self.dump(other_lines, this_path+".OTHER")
110
 
        os.rename(new_file, this_path)
 
122
        rename(new_file, this_path)
111
123
        self.conflict("Diff3 conflict encountered in %s" % this_path)
112
124
 
113
125
    def new_contents_conflict(self, filename, other_contents):
127
139
            % filename)
128
140
        return "skip"
129
141
 
 
142
    def rem_contents_conflict(self, filename, this_contents, base_contents):
 
143
        base_contents(filename+".BASE", self, False)
 
144
        this_contents(filename+".THIS", self, False)
 
145
        return ReplaceContents(this_contents, None)
 
146
 
 
147
    def rem_contents_conflict(self, filename, this_contents, base_contents):
 
148
        base_contents(filename+".BASE", self, False)
 
149
        this_contents(filename+".THIS", self, False)
 
150
        self.conflict("Other branch deleted locally modified file %s" %
 
151
                      filename)
 
152
        return ReplaceContents(this_contents, None)
 
153
 
 
154
    def abs_this_path(self, file_id):
 
155
        """Return the absolute path for a file_id in the this tree."""
 
156
        relpath = self.this_tree.id2path(file_id)
 
157
        return self.this_tree.tree.abspath(relpath)
 
158
 
 
159
    def add_missing_parents(self, file_id, tree):
 
160
        """If some of the parents for file_id are missing, add them."""
 
161
        entry = tree.tree.inventory[file_id]
 
162
        if entry.parent_id not in self.this_tree:
 
163
            return self.create_all_missing(entry.parent_id, tree)
 
164
        else:
 
165
            return self.abs_this_path(entry.parent_id)
 
166
 
 
167
    def create_all_missing(self, file_id, tree):
 
168
        """Add contents for a file_id and all its parents to a tree."""
 
169
        entry = tree.tree.inventory[file_id]
 
170
        if entry.parent_id is not None and entry.parent_id not in self.this_tree:
 
171
            abspath = self.create_all_missing(entry.parent_id, tree)
 
172
        else:
 
173
            abspath = self.abs_this_path(entry.parent_id)
 
174
        entry_path = os.path.join(abspath, entry.name)
 
175
        if not os.path.isdir(entry_path):
 
176
            self.create(file_id, entry_path, tree)
 
177
        return entry_path
 
178
 
 
179
    def create(self, file_id, path, tree, reverse=False):
 
180
        """Uses tree data to create a filesystem object for the file_id"""
 
181
        from merge_core import get_id_contents
 
182
        get_id_contents(file_id, tree)(path, self, reverse)
 
183
 
 
184
    def missing_for_merge(self, file_id, other_path):
 
185
        """The file_id doesn't exist in THIS, but does in OTHER and BASE"""
 
186
        self.conflict("Other branch modified locally deleted file %s" %
 
187
                      other_path)
 
188
        parent_dir = self.add_missing_parents(file_id, self.other_tree)
 
189
        stem = os.path.join(parent_dir, os.path.basename(other_path))
 
190
        self.create(file_id, stem+".OTHER", self.other_tree)
 
191
        self.create(file_id, stem+".BASE", self.base_tree)
 
192
 
130
193
    def finalize(self):
131
194
        if not self.ignore_zero:
132
 
            print "%d conflicts encountered.\n" % self.conflicts
 
195
            note("%d conflicts encountered.\n" % self.conflicts)
133
196
            
134
197
def get_tree(treespec, temp_root, label, local_branch=None):
135
198
    location, revno = treespec
136
 
    branch = find_branch(location)
 
199
    branch = Branch.open_containing(location)
137
200
    if revno is None:
138
201
        revision = None
139
202
    elif revno == -1:
140
 
        revision = branch.last_patch()
 
203
        revision = branch.last_revision()
141
204
    else:
142
 
        revision = branch.lookup_revision(revno)
 
205
        revision = branch.get_rev_id(revno)
143
206
    return branch, get_revid_tree(branch, revision, temp_root, label,
144
207
                                  local_branch)
145
208
 
171
234
        self.tree = tree
172
235
        self.tempdir = tempdir
173
236
        os.mkdir(os.path.join(self.tempdir, "texts"))
 
237
        os.mkdir(os.path.join(self.tempdir, "symlinks"))
174
238
        self.cached = {}
175
239
 
176
240
    def __iter__(self):
185
249
    def get_file_sha1(self, id):
186
250
        return self.tree.get_file_sha1(id)
187
251
 
 
252
    def is_executable(self, id):
 
253
        return self.tree.is_executable(id)
 
254
 
188
255
    def id2path(self, file_id):
189
256
        return self.tree.id2path(file_id)
190
257
 
207
274
        if self.root is not None:
208
275
            return self.tree.abspath(self.tree.id2path(id))
209
276
        else:
210
 
            if self.tree.inventory[id].kind in ("directory", "root_directory"):
 
277
            kind = self.tree.inventory[id].kind
 
278
            if kind in ("directory", "root_directory"):
211
279
                return self.tempdir
212
280
            if not self.cached.has_key(id):
213
 
                path = os.path.join(self.tempdir, "texts", id)
214
 
                outfile = file(path, "wb")
215
 
                outfile.write(self.tree.get_file(id).read())
216
 
                assert(os.path.exists(path))
 
281
                if kind == "file":
 
282
                    path = os.path.join(self.tempdir, "texts", id)
 
283
                    outfile = file(path, "wb")
 
284
                    outfile.write(self.tree.get_file(id).read())
 
285
                    assert(bzrlib.osutils.lexists(path))
 
286
                    if self.tree.is_executable(id):
 
287
                        os.chmod(path, 0755)
 
288
                else:
 
289
                    assert kind == "symlink"
 
290
                    path = os.path.join(self.tempdir, "symlinks", id)
 
291
                    target = self.tree.get_symlink_target(id)
 
292
                    os.symlink(target, path)
217
293
                self.cached[id] = path
218
294
            return self.cached[id]
219
295
 
220
296
 
 
297
def build_working_dir(to_dir):
 
298
    """Build a working directory in an empty directory.
 
299
 
 
300
    to_dir is a directory containing branch metadata but no working files,
 
301
    typically constructed by cloning an existing branch. 
 
302
 
 
303
    This is split out as a special idiomatic case of merge.  It could
 
304
    eventually be done by just building the tree directly calling into 
 
305
    lower-level code (e.g. constructing a changeset).
 
306
    """
 
307
    merge((to_dir, -1), (to_dir, 0), this_dir=to_dir,
 
308
          check_clean=False, ignore_zero=True)
 
309
 
221
310
 
222
311
def merge(other_revision, base_revision,
223
312
          check_clean=True, ignore_zero=False,
234
323
    check_clean
235
324
        If true, this_dir must have no uncommitted changes before the
236
325
        merge begins.
237
 
    all available ancestors of other_revision and base_revision are
 
326
    ignore_zero - If true, suppress the "zero conflicts" message when 
 
327
        there are no conflicts; should be set when doing something we expect
 
328
        to complete perfectly.
 
329
 
 
330
    All available ancestors of other_revision and base_revision are
238
331
    automatically pulled into the branch.
239
332
    """
240
 
    from bzrlib.revision import common_ancestor, MultipleRevisionSources
241
 
    from bzrlib.errors import NoSuchRevision
242
333
    tempdir = tempfile.mkdtemp(prefix="bzr-")
243
334
    try:
244
335
        if this_dir is None:
245
336
            this_dir = '.'
246
 
        this_branch = find_branch(this_dir)
247
 
        this_rev_id = this_branch.last_patch()
 
337
        this_branch = Branch.open_containing(this_dir)
 
338
        this_rev_id = this_branch.last_revision()
248
339
        if this_rev_id is None:
249
340
            raise BzrCommandError("This branch has no commits")
250
341
        if check_clean:
255
346
        other_branch, other_tree = get_tree(other_revision, tempdir, "other",
256
347
                                            this_branch)
257
348
        if other_revision[1] == -1:
258
 
            other_rev_id = other_branch.last_patch()
 
349
            other_rev_id = other_branch.last_revision()
 
350
            if other_rev_id is None:
 
351
                raise NoCommits(other_branch)
259
352
            other_basis = other_rev_id
260
353
        elif other_revision[1] is not None:
261
 
            other_rev_id = other_branch.lookup_revision(other_revision[1])
 
354
            other_rev_id = other_branch.get_rev_id(other_revision[1])
262
355
            other_basis = other_rev_id
263
356
        else:
264
357
            other_rev_id = None
265
 
            other_basis = other_branch.last_patch()
 
358
            other_basis = other_branch.last_revision()
 
359
            if other_basis is None:
 
360
                raise NoCommits(other_branch)
266
361
        if base_revision == [None, None]:
267
 
            base_rev_id = common_ancestor(this_rev_id, other_basis, 
268
 
                                          this_branch)
269
 
            if base_rev_id is None:
 
362
            try:
 
363
                base_rev_id = common_ancestor(this_rev_id, other_basis, 
 
364
                                              this_branch)
 
365
            except NoCommonAncestor:
270
366
                raise UnrelatedBranches()
271
367
            base_tree = get_revid_tree(this_branch, base_rev_id, tempdir, 
272
368
                                       "base", None)
274
370
        else:
275
371
            base_branch, base_tree = get_tree(base_revision, tempdir, "base")
276
372
            if base_revision[1] == -1:
277
 
                base_rev_id = base_branch.last_patch()
 
373
                base_rev_id = base_branch.last_revision()
278
374
            elif base_revision[1] is None:
279
375
                base_rev_id = None
280
376
            else:
281
 
                base_rev_id = base_branch.lookup_revision(base_revision[1])
282
 
            if base_rev_id is not None:
283
 
                base_is_ancestor = is_ancestor(this_rev_id, base_rev_id, 
284
 
                                               MultipleRevisionSources(this_branch, 
285
 
                                                                       base_branch))
286
 
            else:
287
 
                base_is_ancestor = False
 
377
                base_rev_id = base_branch.get_rev_id(base_revision[1])
 
378
            fetch(from_branch=base_branch, to_branch=this_branch)
 
379
            base_is_ancestor = is_ancestor(this_rev_id, base_rev_id,
 
380
                                           this_branch)
288
381
        if file_list is None:
289
382
            interesting_ids = None
290
383
        else:
319
412
             source_file.interesting = source_file.id in interesting_ids
320
413
 
321
414
 
322
 
def generate_cset_optimized(tree_a, tree_b, interesting_ids=None):
323
 
    """Generate a changeset.  If interesting_ids is supplied, only changes
324
 
    to those files will be shown.  Metadata changes are stripped.
325
 
    """ 
326
 
    cset =  generate_changeset(tree_a, tree_b, interesting_ids)
327
 
    for entry in cset.entries.itervalues():
328
 
        entry.metadata_change = None
329
 
    return cset
330
 
 
331
 
 
332
415
def merge_inner(this_branch, other_tree, base_tree, tempdir, 
333
416
                ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
334
417
                interesting_ids=None):
345
428
        return tree.tree.inventory
346
429
 
347
430
    inv_changes = merge_flex(this_tree, base_tree, other_tree,
348
 
                             generate_cset_optimized, get_inventory,
349
 
                             MergeConflictHandler(base_tree.root,
350
 
                                                  ignore_zero=ignore_zero),
 
431
                             generate_changeset, get_inventory,
 
432
                             MergeConflictHandler(this_tree, base_tree,
 
433
                             other_tree, ignore_zero=ignore_zero),
351
434
                             merge_factory=merge_factory, 
352
435
                             interesting_ids=interesting_ids)
353
436
 
357
440
            if path == '.':
358
441
                path = ''
359
442
            else:
360
 
                assert path.startswith('./'), "path is %s" % path
 
443
                assert path.startswith('.' + os.sep), "path is %s" % path
361
444
            path = path[2:]
362
445
        adjust_ids.append((path, id))
363
446
    if len(adjust_ids) > 0: