/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: 2006-01-13 06:31:42 UTC
  • Revision ID: mbp@sourcefrog.net-20060113063142-8e706dc1483c69e1
Bump version to 0.8pre

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
 
from merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
2
 
from changeset import generate_changeset, ExceptionConflictHandler
3
 
from changeset import Inventory, Diff3Merge
4
 
from bzrlib import find_branch
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
import os
 
19
import shutil
 
20
import errno
 
21
 
5
22
import bzrlib.osutils
6
 
from bzrlib.errors import BzrCommandError
 
23
import bzrlib.revision
 
24
from bzrlib.merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
 
25
from bzrlib.merge_core import WeaveMerge
 
26
from bzrlib.changeset import generate_changeset, ExceptionConflictHandler
 
27
from bzrlib.changeset import Inventory, Diff3Merge, ReplaceContents
 
28
from bzrlib.branch import Branch
 
29
from bzrlib.errors import (BzrCommandError,
 
30
                           UnrelatedBranches,
 
31
                           NoCommonAncestor,
 
32
                           NoCommits,
 
33
                           WorkingTreeNotRevision,
 
34
                           NotBranchError,
 
35
                           NotVersionedError,
 
36
                           BzrError)
7
37
from bzrlib.delta import compare_trees
8
 
from trace import mutter, warning
9
 
import os.path
10
 
import tempfile
11
 
import shutil
12
 
import errno
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
 
 
 
38
from bzrlib.trace import mutter, warning, note
 
39
from bzrlib.fetch import greedy_fetch, fetch
 
40
from bzrlib.revision import is_ancestor, NULL_REVISION
 
41
from bzrlib.osutils import rename, pathjoin
 
42
from bzrlib.revision import common_ancestor, MultipleRevisionSources
 
43
from bzrlib.errors import NoSuchRevision
 
44
 
 
45
# TODO: Report back as changes are merged in
 
46
 
 
47
# TODO: build_working_dir can be built on something simpler than merge()
 
48
 
 
49
# FIXME: merge() parameters seem oriented towards the command line
 
50
# NOTABUG: merge is a helper for commandline functions.  merge_inner is the
 
51
#          the core functionality.
 
52
 
 
53
# comments from abentley on irc: merge happens in two stages, each
 
54
# of which generates a changeset object
 
55
 
 
56
# stage 1: generate OLD->OTHER,
 
57
# stage 2: use MINE and OLD->OTHER to generate MINE -> RESULT
20
58
 
21
59
class MergeConflictHandler(ExceptionConflictHandler):
22
 
    """Handle conflicts encountered while merging"""
23
 
    def __init__(self, dir, ignore_zero=False):
24
 
        ExceptionConflictHandler.__init__(self, dir)
 
60
    """Handle conflicts encountered while merging.
 
61
 
 
62
    This subclasses ExceptionConflictHandler, so that any types of
 
63
    conflict that are not explicitly handled cause an exception and
 
64
    terminate the merge.
 
65
    """
 
66
    def __init__(self, this_tree, base_tree, other_tree, ignore_zero=False):
 
67
        ExceptionConflictHandler.__init__(self)
25
68
        self.conflicts = 0
26
69
        self.ignore_zero = ignore_zero
 
70
        self.this_tree = this_tree
 
71
        self.base_tree = base_tree
 
72
        self.other_tree = other_tree
27
73
 
28
74
    def copy(self, source, dest):
29
75
        """Copy the text and mode of a file
36
82
            d_file.write(line)
37
83
        os.chmod(dest, 0777 & os.stat(source).st_mode)
38
84
 
39
 
    def add_suffix(self, name, suffix, last_new_name=None):
 
85
    def dump(self, lines, dest):
 
86
        """Copy the text and mode of a file
 
87
        :param source: The path of the file to copy
 
88
        :param dest: The distination file to create
 
89
        """
 
90
        d_file = file(dest, "wb")
 
91
        for line in lines:
 
92
            d_file.write(line)
 
93
 
 
94
    def add_suffix(self, name, suffix, last_new_name=None, fix_inventory=True):
40
95
        """Rename a file to append a suffix.  If the new name exists, the
41
96
        suffix is added repeatedly until a non-existant name is found
42
97
 
48
103
            last_new_name = name
49
104
        new_name = last_new_name+suffix
50
105
        try:
51
 
            os.rename(name, new_name)
52
 
            return new_name
 
106
            rename(name, new_name)
 
107
            if fix_inventory is True:
 
108
                try:
 
109
                    relpath = self.this_tree.relpath(name)
 
110
                except NotBranchError:
 
111
                    relpath = None
 
112
                if relpath is not None:
 
113
                    file_id = self.this_tree.path2id(relpath)
 
114
                    if file_id is not None:
 
115
                        new_path = self.this_tree.relpath(new_name)
 
116
                        rename(new_name, name)
 
117
                        self.this_tree.rename_one(relpath, new_path)
 
118
                        assert self.this_tree.id2path(file_id) == new_path
53
119
        except OSError, e:
54
120
            if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
55
121
                raise
56
 
            return self.add_suffix(name, suffix, last_new_name=new_name)
 
122
            return self.add_suffix(name, suffix, last_new_name=new_name, 
 
123
                                   fix_inventory=fix_inventory)
 
124
        return new_name
57
125
 
58
126
    def conflict(self, text):
59
127
        warning(text)
60
128
        self.conflicts += 1
61
129
        
62
130
 
63
 
    def merge_conflict(self, new_file, this_path, base_path, other_path):
 
131
    def merge_conflict(self, new_file, this_path, base_lines, other_lines):
64
132
        """
65
133
        Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER.  The
66
134
        main file will be a version with diff3 conflicts.
69
137
        :param base_path: Path to the file text for the BASE tree
70
138
        :param other_path: Path to the file text for the OTHER tree
71
139
        """
72
 
        self.add_suffix(this_path, ".THIS")
73
 
        self.copy(base_path, this_path+".BASE")
74
 
        self.copy(other_path, this_path+".OTHER")
75
 
        os.rename(new_file, this_path)
 
140
        self.add_suffix(this_path, ".THIS", fix_inventory=False)
 
141
        self.dump(base_lines, this_path+".BASE")
 
142
        self.dump(other_lines, this_path+".OTHER")
 
143
        rename(new_file, this_path)
76
144
        self.conflict("Diff3 conflict encountered in %s" % this_path)
77
145
 
 
146
    def weave_merge_conflict(self, filename, weave, other_i, out_file):
 
147
        """
 
148
        Handle weave conflicts by producing a .THIS, and .OTHER.  The
 
149
        main file will be a version with diff3-style conflicts.
 
150
        """
 
151
        self.add_suffix(filename, ".THIS", fix_inventory=False)
 
152
        out_file.commit()
 
153
        self.dump(weave.get_iter(other_i), filename+".OTHER")
 
154
        self.conflict("Text conflict encountered in %s" % filename)
 
155
 
 
156
    def new_contents_conflict(self, filename, other_contents):
 
157
        """Conflicting contents for newly added file."""
 
158
        other_contents(filename + ".OTHER", self, False)
 
159
        self.conflict("Conflict in newly added file %s" % filename)
 
160
    
 
161
 
78
162
    def target_exists(self, entry, target, old_path):
79
163
        """Handle the case when the target file or dir exists"""
80
164
        moved_path = self.add_suffix(target, ".moved")
86
170
            % filename)
87
171
        return "skip"
88
172
 
 
173
    def rem_contents_conflict(self, filename, this_contents, base_contents):
 
174
        base_contents(filename+".BASE", self)
 
175
        this_contents(filename+".THIS", self)
 
176
        self.conflict("Other branch deleted locally modified file %s" %
 
177
                      filename)
 
178
        return ReplaceContents(this_contents, None)
 
179
 
 
180
    def abs_this_path(self, file_id):
 
181
        """Return the absolute path for a file_id in the this tree."""
 
182
        return self.this_tree.id2abspath(file_id)
 
183
 
 
184
    def add_missing_parents(self, file_id, tree):
 
185
        """If some of the parents for file_id are missing, add them."""
 
186
        entry = tree.inventory[file_id]
 
187
        if entry.parent_id not in self.this_tree:
 
188
            return self.create_all_missing(entry.parent_id, tree)
 
189
        else:
 
190
            return self.abs_this_path(entry.parent_id)
 
191
 
 
192
    def create_all_missing(self, file_id, tree):
 
193
        """Add contents for a file_id and all its parents to a tree."""
 
194
        entry = tree.inventory[file_id]
 
195
        if entry.parent_id is not None and entry.parent_id not in self.this_tree:
 
196
            abspath = self.create_all_missing(entry.parent_id, tree)
 
197
        else:
 
198
            abspath = self.abs_this_path(entry.parent_id)
 
199
        entry_path = pathjoin(abspath, entry.name)
 
200
        if not os.path.isdir(entry_path):
 
201
            self.create(file_id, entry_path, tree)
 
202
        return entry_path
 
203
 
 
204
    def create(self, file_id, path, tree):
 
205
        """Uses tree data to create a filesystem object for the file_id"""
 
206
        from changeset import get_contents
 
207
        get_contents(tree, file_id)(path, self)
 
208
 
 
209
    def missing_for_merge(self, file_id, other_path):
 
210
        """The file_id doesn't exist in THIS, but does in OTHER and BASE"""
 
211
        self.conflict("Other branch modified locally deleted file %s" %
 
212
                      other_path)
 
213
        parent_dir = self.add_missing_parents(file_id, self.other_tree)
 
214
        stem = pathjoin(parent_dir, os.path.basename(other_path))
 
215
        self.create(file_id, stem+".OTHER", self.other_tree)
 
216
        self.create(file_id, stem+".BASE", self.base_tree)
 
217
 
 
218
    def threeway_contents_conflict(filename, this_contents, base_contents,
 
219
                                   other_contents):
 
220
        self.conflict("Three-way conflict merging %s" % filename)
 
221
 
89
222
    def finalize(self):
90
 
        if not self.ignore_zero:
91
 
            print "%d conflicts encountered.\n" % self.conflicts
 
223
        if self.conflicts == 0:
 
224
            if not self.ignore_zero:
 
225
                note("All changes applied successfully.")
 
226
        else:
 
227
            note("%d conflicts encountered." % self.conflicts)
92
228
            
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
 
 
104
 
def get_tree(treespec, temp_root, label):
 
229
def get_tree(treespec, local_branch=None):
105
230
    location, revno = treespec
106
 
    branch = find_branch(location)
 
231
    branch = Branch.open_containing(location)[0]
107
232
    if revno is None:
 
233
        revision = None
 
234
    elif revno == -1:
 
235
        revision = branch.last_revision()
 
236
    else:
 
237
        revision = branch.get_rev_id(revno)
 
238
        if revision is None:
 
239
            revision = NULL_REVISION
 
240
    return branch, get_revid_tree(branch, revision, local_branch)
 
241
 
 
242
def get_revid_tree(branch, revision, local_branch):
 
243
    if revision is None:
108
244
        base_tree = branch.working_tree()
109
 
    elif revno == -1:
110
 
        base_tree = branch.basis_tree()
111
245
    else:
112
 
        base_tree = branch.revision_tree(branch.lookup_revision(revno))
113
 
    temp_path = os.path.join(temp_root, label)
114
 
    os.mkdir(temp_path)
115
 
    return branch, MergeTree(base_tree, temp_path)
116
 
 
117
 
 
118
 
def abspath(tree, file_id):
119
 
    path = tree.inventory.id2path(file_id)
120
 
    if path == "":
121
 
        return "./."
122
 
    return "./" + path
 
246
        if local_branch is not None:
 
247
            greedy_fetch(local_branch, branch, revision)
 
248
            base_tree = local_branch.revision_tree(revision)
 
249
        else:
 
250
            base_tree = branch.revision_tree(revision)
 
251
    return base_tree
 
252
 
123
253
 
124
254
def file_exists(tree, file_id):
125
255
    return tree.has_filename(tree.id2path(file_id))
126
256
    
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
 
 
134
 
 
135
 
class MergeTree(object):
136
 
    def __init__(self, tree, tempdir):
137
 
        object.__init__(self)
138
 
        if hasattr(tree, "basedir"):
139
 
            self.root = tree.basedir
140
 
        else:
141
 
            self.root = None
142
 
        self.inventory = inventory_map(tree)
143
 
        self.tree = tree
144
 
        self.tempdir = tempdir
145
 
        os.mkdir(os.path.join(self.tempdir, "texts"))
146
 
        self.cached = {}
147
 
 
148
 
    def readonly_path(self, id):
149
 
        if id not in self.tree:
150
 
            return None
151
 
        if self.root is not None:
152
 
            return self.tree.abspath(self.tree.id2path(id))
153
 
        else:
154
 
            if self.tree.inventory[id].kind in ("directory", "root_directory"):
155
 
                return self.tempdir
156
 
            if not self.cached.has_key(id):
157
 
                path = os.path.join(self.tempdir, "texts", id)
158
 
                outfile = file(path, "wb")
159
 
                outfile.write(self.tree.get_file(id).read())
160
 
                assert(os.path.exists(path))
161
 
                self.cached[id] = path
162
 
            return self.cached[id]
163
 
 
 
257
 
 
258
def build_working_dir(to_dir):
 
259
    """Build a working directory in an empty directory.
 
260
 
 
261
    to_dir is a directory containing branch metadata but no working files,
 
262
    typically constructed by cloning an existing branch. 
 
263
 
 
264
    This is split out as a special idiomatic case of merge.  It could
 
265
    eventually be done by just building the tree directly calling into 
 
266
    lower-level code (e.g. constructing a changeset).
 
267
    """
 
268
    # RBC 20051019 is this not just 'export' ?
 
269
    # AB Well, export doesn't take care of inventory...
 
270
    this_branch = Branch.open_containing(to_dir)[0]
 
271
    transform_tree(this_branch.working_tree(), this_branch.basis_tree())
 
272
 
 
273
 
 
274
def transform_tree(from_tree, to_tree, interesting_ids=None):
 
275
    merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
 
276
                interesting_ids=interesting_ids)
164
277
 
165
278
 
166
279
def merge(other_revision, base_revision,
167
280
          check_clean=True, ignore_zero=False,
168
281
          this_dir=None, backup_files=False, merge_type=ApplyMerge3,
169
 
          file_list=None):
 
282
          file_list=None, show_base=False, reprocess=False):
170
283
    """Merge changes into a tree.
171
284
 
172
285
    base_revision
173
 
        Base for three-way merge.
 
286
        list(path, revno) Base for three-way merge.  
 
287
        If [None, None] then a base will be automatically determined.
174
288
    other_revision
175
 
        Other revision for three-way merge.
 
289
        list(path, revno) Other revision for three-way merge.
176
290
    this_dir
177
291
        Directory to merge changes into; '.' by default.
178
292
    check_clean
179
293
        If true, this_dir must have no uncommitted changes before the
180
294
        merge begins.
 
295
    ignore_zero - If true, suppress the "zero conflicts" message when 
 
296
        there are no conflicts; should be set when doing something we expect
 
297
        to complete perfectly.
 
298
    file_list - If supplied, merge only changes to selected files.
 
299
 
 
300
    All available ancestors of other_revision and base_revision are
 
301
    automatically pulled into the branch.
 
302
 
 
303
    The revno may be -1 to indicate the last revision on the branch, which is
 
304
    the typical case.
 
305
 
 
306
    This function is intended for use from the command line; programmatic
 
307
    clients might prefer to call merge_inner(), which has less magic behavior.
181
308
    """
182
 
    tempdir = tempfile.mkdtemp(prefix="bzr-")
183
 
    try:
184
 
        if this_dir is None:
185
 
            this_dir = '.'
186
 
        this_branch = find_branch(this_dir)
 
309
    if this_dir is None:
 
310
        this_dir = u'.'
 
311
    this_branch = Branch.open_containing(this_dir)[0]
 
312
    if show_base and not merge_type is ApplyMerge3:
 
313
        raise BzrCommandError("Show-base is not supported for this merge"
 
314
                              " type. %s" % merge_type)
 
315
    if reprocess and not merge_type is ApplyMerge3:
 
316
        raise BzrCommandError("Reprocess is not supported for this merge"
 
317
                              " type. %s" % merge_type)
 
318
    if reprocess and show_base:
 
319
        raise BzrCommandError("Cannot reprocess and show base.")
 
320
    merger = Merger(this_branch)
 
321
    merger.check_basis(check_clean)
 
322
    merger.set_other(other_revision)
 
323
    merger.set_base(base_revision)
 
324
    if merger.base_rev_id == merger.other_rev_id:
 
325
        note('Nothing to do.')
 
326
        return 0
 
327
    merger.backup_files = backup_files
 
328
    merger.merge_type = merge_type 
 
329
    merger.set_interesting_files(file_list)
 
330
    merger.show_base = show_base 
 
331
    merger.reprocess = reprocess
 
332
    merger.conflict_handler = MergeConflictHandler(merger.this_tree, 
 
333
                                                   merger.base_tree, 
 
334
                                                   merger.other_tree,
 
335
                                                   ignore_zero=ignore_zero)
 
336
    conflicts = merger.do_merge()
 
337
    merger.set_pending()
 
338
    return conflicts
 
339
 
 
340
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
 
341
                backup_files=False, 
 
342
                merge_type=ApplyMerge3, 
 
343
                interesting_ids=None, 
 
344
                show_base=False, 
 
345
                reprocess=False, 
 
346
                other_rev_id=None,
 
347
                interesting_files=None):
 
348
    """Primary interface for merging. 
 
349
 
 
350
        typical use is probably 
 
351
        'merge_inner(branch, branch.get_revision_tree(other_revision),
 
352
                     branch.get_revision_tree(base_revision))'
 
353
        """
 
354
    merger = Merger(this_branch, other_tree, base_tree)
 
355
    merger.backup_files = backup_files
 
356
    merger.merge_type = merge_type
 
357
    merger.interesting_ids = interesting_ids
 
358
    if interesting_files:
 
359
        assert not interesting_ids, ('Only supply interesting_ids'
 
360
                                     ' or interesting_files')
 
361
        merger._set_interesting_files(interesting_files)
 
362
    merger.show_base = show_base 
 
363
    merger.reprocess = reprocess
 
364
    merger.conflict_handler = MergeConflictHandler(merger.this_tree, base_tree, 
 
365
                                                   other_tree,
 
366
                                                   ignore_zero=ignore_zero)
 
367
    merger.other_rev_id = other_rev_id
 
368
    merger.other_basis = other_rev_id
 
369
    return merger.do_merge()
 
370
 
 
371
 
 
372
class Merger(object):
 
373
    def __init__(self, this_branch, other_tree=None, base_tree=None):
 
374
        object.__init__(self)
 
375
        self.this_branch = this_branch
 
376
        self.this_basis = this_branch.last_revision()
 
377
        self.this_rev_id = None
 
378
        self.this_tree = this_branch.working_tree()
 
379
        self.this_revision_tree = None
 
380
        self.this_basis_tree = None
 
381
        self.other_tree = other_tree
 
382
        self.base_tree = base_tree
 
383
        self.ignore_zero = False
 
384
        self.backup_files = False
 
385
        self.interesting_ids = None
 
386
        self.show_base = False
 
387
        self.reprocess = False
 
388
        self.conflict_handler = MergeConflictHandler(self.this_tree, base_tree, 
 
389
                                                     other_tree)
 
390
 
 
391
    def revision_tree(self, revision_id):
 
392
        return self.this_branch.revision_tree(revision_id)
 
393
 
 
394
    def ensure_revision_trees(self):
 
395
        if self.this_revision_tree is None:
 
396
            self.this_basis_tree = self.this_branch.revision_tree(
 
397
                self.this_basis)
 
398
            if self.this_basis == self.this_rev_id:
 
399
                self.this_revision_tree = self.this_basis_tree
 
400
 
 
401
 
 
402
        if self.other_rev_id is None:
 
403
            other_basis_tree = self.revision_tree(self.other_basis)
 
404
            changes = compare_trees(self.other_tree, other_basis_tree)
 
405
            if changes.has_changed():
 
406
                raise WorkingTreeNotRevision(self.this_tree)
 
407
            other_rev_id = other_basis
 
408
            self.other_tree = other_basis_tree
 
409
 
 
410
 
 
411
    def file_revisions(self, file_id):
 
412
        self.ensure_revision_trees()
 
413
        def get_id(tree, file_id):
 
414
            revision_id = tree.inventory[file_id].revision
 
415
            assert revision_id is not None
 
416
            return revision_id
 
417
        if self.this_rev_id is None:
 
418
            if self.this_basis_tree.get_file_sha1(file_id) != \
 
419
                self.this_tree.get_file_sha1(file_id):
 
420
                raise WorkingTreeNotRevision(self.this_tree)
 
421
 
 
422
        trees = (self.this_basis_tree, self.other_tree)
 
423
        return [get_id(tree, file_id) for tree in trees]
 
424
            
 
425
 
 
426
    def merge_factory(self, file_id, base, other):
 
427
        if self.merge_type.history_based:
 
428
            if self.show_base is True:
 
429
                raise BzrError("Cannot show base for hisory-based merges")
 
430
            if self.reprocess is True:
 
431
                raise BzrError("Cannot reprocess history-based merges")
 
432
                
 
433
            t_revid, o_revid = self.file_revisions(file_id)
 
434
            weave = self.this_basis_tree.get_weave(file_id)
 
435
            contents_change = self.merge_type(weave, t_revid, o_revid)
 
436
        else:
 
437
            if self.show_base is True or self.reprocess is True:
 
438
                contents_change = self.merge_type(file_id, base, other, 
 
439
                                                  show_base=self.show_base, 
 
440
                                                  reprocess=self.reprocess)
 
441
            else:
 
442
                contents_change = self.merge_type(file_id, base, other)
 
443
        if self.backup_files:
 
444
            contents_change = BackupBeforeChange(contents_change)
 
445
        return contents_change
 
446
 
 
447
    def check_basis(self, check_clean):
 
448
        if self.this_basis is None:
 
449
            raise BzrCommandError("This branch has no commits")
187
450
        if check_clean:
188
 
            changes = compare_trees(this_branch.working_tree(), 
189
 
                                    this_branch.basis_tree(), False)
190
 
            if changes.has_changed():
 
451
            self.compare_basis()
 
452
            if self.this_basis != self.this_rev_id:
191
453
                raise BzrCommandError("Working tree has uncommitted changes.")
192
 
        other_branch, other_tree = get_tree(other_revision, tempdir, "other")
 
454
 
 
455
    def compare_basis(self):
 
456
        changes = compare_trees(self.this_branch.working_tree(), 
 
457
                                self.this_branch.basis_tree(), False)
 
458
        if not changes.has_changed():
 
459
            self.this_rev_id = self.this_basis
 
460
 
 
461
    def set_interesting_files(self, file_list):
 
462
        try:
 
463
            self._set_interesting_files(file_list)
 
464
        except NotVersionedError, e:
 
465
            raise BzrCommandError("%s is not a source file in any"
 
466
                                      " tree." % e.path)
 
467
 
 
468
    def _set_interesting_files(self, file_list):
 
469
        """Set the list of interesting ids from a list of files."""
 
470
        if file_list is None:
 
471
            self.interesting_ids = None
 
472
            return
 
473
 
 
474
        interesting_ids = set()
 
475
        for fname in file_list:
 
476
            path = self.this_tree.relpath(fname)
 
477
            found_id = False
 
478
            for tree in (self.this_tree, self.base_tree, self.other_tree):
 
479
                file_id = tree.inventory.path2id(path)
 
480
                if file_id is not None:
 
481
                    interesting_ids.add(file_id)
 
482
                    found_id = True
 
483
            if not found_id:
 
484
                raise NotVersionedError(path=fname)
 
485
        self.interesting_ids = interesting_ids
 
486
 
 
487
    def set_pending(self):
 
488
        if not self.base_is_ancestor:
 
489
            return
 
490
        if self.other_rev_id is None:
 
491
            return
 
492
        if self.other_rev_id in self.this_branch.get_ancestry(self.this_basis):
 
493
            return
 
494
        self.this_branch.working_tree().add_pending_merge(self.other_rev_id)
 
495
 
 
496
    def set_other(self, other_revision):
 
497
        other_branch, self.other_tree = get_tree(other_revision, 
 
498
                                                 self.this_branch)
 
499
        if other_revision[1] == -1:
 
500
            self.other_rev_id = other_branch.last_revision()
 
501
            if self.other_rev_id is None:
 
502
                raise NoCommits(other_branch)
 
503
            self.other_basis = self.other_rev_id
 
504
        elif other_revision[1] is not None:
 
505
            self.other_rev_id = other_branch.get_rev_id(other_revision[1])
 
506
            self.other_basis = self.other_rev_id
 
507
        else:
 
508
            self.other_rev_id = None
 
509
            self.other_basis = other_branch.last_revision()
 
510
            if self.other_basis is None:
 
511
                raise NoCommits(other_branch)
 
512
        fetch(from_branch=other_branch, to_branch=self.this_branch, 
 
513
              last_revision=self.other_basis)
 
514
 
 
515
    def set_base(self, base_revision):
 
516
        mutter("doing merge() with no base_revision specified")
193
517
        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:
 
518
            try:
 
519
                self.base_rev_id = common_ancestor(self.this_basis, 
 
520
                                                   self.other_basis, 
 
521
                                                   self.this_branch)
 
522
            except NoCommonAncestor:
201
523
                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)
223
 
    finally:
224
 
        shutil.rmtree(tempdir)
225
 
 
226
 
 
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
 
    """
238
 
    for file_id in tree_a.tree.inventory:
239
 
        if file_id not in tree_b.tree.inventory:
240
 
            continue
241
 
        entry_a = tree_a.tree.inventory[file_id]
242
 
        entry_b = tree_b.tree.inventory[file_id]
243
 
        if (entry_a.kind, entry_b.kind) != ("file", "file"):
244
 
            continue
245
 
        if None in (entry_a.text_id, entry_b.text_id):
246
 
            continue
247
 
        if entry_a.text_id != entry_b.text_id:
248
 
            continue
249
 
        inventory_a[abspath(tree_a.tree, file_id)].interesting = False
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)
264
 
    cset =  generate_changeset(tree_a, tree_b, inventory_a, inventory_b)
265
 
    for entry in cset.entries.itervalues():
266
 
        entry.metadata_change = None
267
 
    return cset
268
 
 
269
 
 
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]
285
 
 
286
 
    def get_inventory(tree):
287
 
        return tree.inventory
288
 
 
289
 
    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)
294
 
 
295
 
    adjust_ids = []
296
 
    for id, path in inv_changes.iteritems():
297
 
        if path is not None:
298
 
            if path == '.':
299
 
                path = ''
300
 
            else:
301
 
                assert path.startswith('./')
302
 
            path = path[2:]
303
 
        adjust_ids.append((path, id))
304
 
    this_branch.set_inventory(regen_inventory(this_branch, this_tree.root, adjust_ids))
305
 
 
306
 
 
307
 
def regen_inventory(this_branch, root, new_entries):
308
 
    old_entries = this_branch.read_working_inventory()
309
 
    new_inventory = {}
310
 
    by_path = {}
311
 
    for file_id in old_entries:
312
 
        entry = old_entries[file_id]
313
 
        path = old_entries.id2path(file_id)
314
 
        new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
315
 
        by_path[path] = file_id
316
 
    
317
 
    deletions = 0
318
 
    insertions = 0
319
 
    new_path_list = []
320
 
    for path, file_id in new_entries:
321
 
        if path is None:
322
 
            del new_inventory[file_id]
323
 
            deletions += 1
324
 
        else:
325
 
            new_path_list.append((path, file_id))
326
 
            if file_id not in old_entries:
327
 
                insertions += 1
328
 
    # Ensure no file is added before its parent
329
 
    new_path_list.sort()
330
 
    for path, file_id in new_path_list:
331
 
        if path == '':
332
 
            parent = None
333
 
        else:
334
 
            parent = by_path[os.path.dirname(path)]
335
 
        kind = bzrlib.osutils.file_kind(os.path.join(root, path))
336
 
        new_inventory[file_id] = (path, file_id, parent, kind)
337
 
        by_path[path] = file_id 
338
 
 
339
 
    # Get a list in insertion order
340
 
    new_inventory_list = new_inventory.values()
341
 
    mutter ("""Inventory regeneration:
342
 
old length: %i insertions: %i deletions: %i new_length: %i"""\
343
 
        % (len(old_entries), insertions, deletions, len(new_inventory_list)))
344
 
    assert len(new_inventory_list) == len(old_entries) + insertions - deletions
345
 
    new_inventory_list.sort()
346
 
    return new_inventory_list
 
524
            self.base_tree = get_revid_tree(self.this_branch, self.base_rev_id,
 
525
                                            None)
 
526
            self.base_is_ancestor = True
 
527
        else:
 
528
            base_branch, self.base_tree = get_tree(base_revision)
 
529
            if base_revision[1] == -1:
 
530
                self.base_rev_id = base_branch.last_revision()
 
531
            elif base_revision[1] is None:
 
532
                self.base_rev_id = None
 
533
            else:
 
534
                self.base_rev_id = base_branch.get_rev_id(base_revision[1])
 
535
            fetch(from_branch=base_branch, to_branch=self.this_branch)
 
536
            self.base_is_ancestor = is_ancestor(self.this_basis, 
 
537
                                                self.base_rev_id,
 
538
                                                self.this_branch)
 
539
 
 
540
    def do_merge(self):
 
541
        def get_inventory(tree):
 
542
            return tree.inventory
 
543
        
 
544
        inv_changes = merge_flex(self.this_tree, self.base_tree, 
 
545
                                 self.other_tree,
 
546
                                 generate_changeset, get_inventory,
 
547
                                 self.conflict_handler,
 
548
                                 merge_factory=self.merge_factory, 
 
549
                                 interesting_ids=self.interesting_ids)
 
550
 
 
551
        adjust_ids = []
 
552
        for id, path in inv_changes.iteritems():
 
553
            if path is not None:
 
554
                if path == u'.':
 
555
                    path = u''
 
556
                else:
 
557
                    assert path.startswith('.' + '/') or path.startswith('.' + '\\'), "path is %s" % path
 
558
                path = path[2:]
 
559
            adjust_ids.append((path, id))
 
560
        if len(adjust_ids) > 0:
 
561
            self.this_branch.working_tree().set_inventory(self.regen_inventory(adjust_ids))
 
562
        conflicts = self.conflict_handler.conflicts
 
563
        self.conflict_handler.finalize()
 
564
        return conflicts
 
565
 
 
566
    def regen_inventory(self, new_entries):
 
567
        old_entries = self.this_branch.working_tree().read_working_inventory()
 
568
        new_inventory = {}
 
569
        by_path = {}
 
570
        new_entries_map = {} 
 
571
        for path, file_id in new_entries:
 
572
            if path is None:
 
573
                continue
 
574
            new_entries_map[file_id] = path
 
575
 
 
576
        def id2path(file_id):
 
577
            path = new_entries_map.get(file_id)
 
578
            if path is not None:
 
579
                return path
 
580
            entry = old_entries[file_id]
 
581
            if entry.parent_id is None:
 
582
                return entry.name
 
583
            return pathjoin(id2path(entry.parent_id), entry.name)
 
584
            
 
585
        for file_id in old_entries:
 
586
            entry = old_entries[file_id]
 
587
            path = id2path(file_id)
 
588
            new_inventory[file_id] = (path, file_id, entry.parent_id, 
 
589
                                      entry.kind)
 
590
            by_path[path] = file_id
 
591
        
 
592
        deletions = 0
 
593
        insertions = 0
 
594
        new_path_list = []
 
595
        for path, file_id in new_entries:
 
596
            if path is None:
 
597
                del new_inventory[file_id]
 
598
                deletions += 1
 
599
            else:
 
600
                new_path_list.append((path, file_id))
 
601
                if file_id not in old_entries:
 
602
                    insertions += 1
 
603
        # Ensure no file is added before its parent
 
604
        new_path_list.sort()
 
605
        for path, file_id in new_path_list:
 
606
            if path == '':
 
607
                parent = None
 
608
            else:
 
609
                parent = by_path[os.path.dirname(path)]
 
610
            abspath = pathjoin(self.this_tree.basedir, path)
 
611
            kind = bzrlib.osutils.file_kind(abspath)
 
612
            new_inventory[file_id] = (path, file_id, parent, kind)
 
613
            by_path[path] = file_id 
 
614
 
 
615
        # Get a list in insertion order
 
616
        new_inventory_list = new_inventory.values()
 
617
        mutter ("""Inventory regeneration:
 
618
    old length: %i insertions: %i deletions: %i new_length: %i"""\
 
619
            % (len(old_entries), insertions, deletions, 
 
620
               len(new_inventory_list)))
 
621
        assert len(new_inventory_list) == len(old_entries) + insertions\
 
622
            - deletions
 
623
        new_inventory_list.sort()
 
624
        return new_inventory_list
347
625
 
348
626
merge_types = {     "merge3": (ApplyMerge3, "Native diff3-style merge"), 
349
 
                     "diff3": (Diff3Merge,  "Merge using external diff3")
 
627
                     "diff3": (Diff3Merge,  "Merge using external diff3"),
 
628
                     'weave': (WeaveMerge, "Weave-based merge")
350
629
              }
351
630