~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Robert Collins
  • Date: 2005-10-17 21:57:32 UTC
  • mto: This revision was merged to the branch mainline in revision 1462.
  • Revision ID: robertc@robertcollins.net-20051017215732-08f487800e726748
Allow creation of testaments from uncommitted data, and use that to get signatures before committing revisions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
23
23
import bzrlib.osutils
24
24
import bzrlib.revision
25
25
from bzrlib.merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
26
 
from bzrlib.merge_core import WeaveMerge
27
26
from bzrlib.changeset import generate_changeset, ExceptionConflictHandler
28
27
from bzrlib.changeset import Inventory, Diff3Merge, ReplaceContents
29
28
from bzrlib.branch import Branch
30
 
from bzrlib.errors import (BzrCommandError,
31
 
                           UnrelatedBranches,
32
 
                           NoCommonAncestor,
33
 
                           NoCommits,
34
 
                           WorkingTreeNotRevision,
35
 
                           NotBranchError,
36
 
                           NotVersionedError,
37
 
                           BzrError)
 
29
from bzrlib.errors import BzrCommandError, UnrelatedBranches, NoCommonAncestor
 
30
from bzrlib.errors import NoCommits
38
31
from bzrlib.delta import compare_trees
39
32
from bzrlib.trace import mutter, warning, note
40
33
from bzrlib.fetch import greedy_fetch, fetch
41
 
from bzrlib.revision import is_ancestor, NULL_REVISION
 
34
from bzrlib.revision import is_ancestor
42
35
from bzrlib.osutils import rename
43
36
from bzrlib.revision import common_ancestor, MultipleRevisionSources
44
37
from bzrlib.errors import NoSuchRevision
45
38
 
46
 
# TODO: Report back as changes are merged in
47
 
 
48
39
# TODO: build_working_dir can be built on something simpler than merge()
49
40
 
50
41
# FIXME: merge() parameters seem oriented towards the command line
92
83
        for line in lines:
93
84
            d_file.write(line)
94
85
 
95
 
    def add_suffix(self, name, suffix, last_new_name=None, fix_inventory=True):
 
86
    def add_suffix(self, name, suffix, last_new_name=None):
96
87
        """Rename a file to append a suffix.  If the new name exists, the
97
88
        suffix is added repeatedly until a non-existant name is found
98
89
 
105
96
        new_name = last_new_name+suffix
106
97
        try:
107
98
            rename(name, new_name)
108
 
            if fix_inventory is True:
109
 
                try:
110
 
                    relpath = self.this_tree.relpath(name)
111
 
                except NotBranchError:
112
 
                    relpath = None
113
 
                if relpath is not None:
114
 
                    file_id = self.this_tree.path2id(relpath)
115
 
                    if file_id is not None:
116
 
                        new_path = self.this_tree.relpath(new_name)
117
 
                        rename(new_name, name)
118
 
                        self.this_tree.rename_one(relpath, new_path)
119
 
                        assert self.this_tree.id2path(file_id) == new_path
 
99
            return new_name
120
100
        except OSError, e:
121
101
            if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
122
102
                raise
123
 
            return self.add_suffix(name, suffix, last_new_name=new_name, 
124
 
                                   fix_inventory=fix_inventory)
125
 
        return new_name
 
103
            return self.add_suffix(name, suffix, last_new_name=new_name)
126
104
 
127
105
    def conflict(self, text):
128
106
        warning(text)
138
116
        :param base_path: Path to the file text for the BASE tree
139
117
        :param other_path: Path to the file text for the OTHER tree
140
118
        """
141
 
        self.add_suffix(this_path, ".THIS", fix_inventory=False)
 
119
        self.add_suffix(this_path, ".THIS")
142
120
        self.dump(base_lines, this_path+".BASE")
143
121
        self.dump(other_lines, this_path+".OTHER")
144
122
        rename(new_file, this_path)
145
123
        self.conflict("Diff3 conflict encountered in %s" % this_path)
146
124
 
147
 
    def weave_merge_conflict(self, filename, weave, other_i, out_file):
148
 
        """
149
 
        Handle weave conflicts by producing a .THIS, and .OTHER.  The
150
 
        main file will be a version with diff3-style conflicts.
151
 
        """
152
 
        self.add_suffix(filename, ".THIS", fix_inventory=False)
153
 
        out_file.commit()
154
 
        self.dump(weave.get_iter(other_i), filename+".OTHER")
155
 
        self.conflict("Text conflict encountered in %s" % filename)
156
 
 
157
125
    def new_contents_conflict(self, filename, other_contents):
158
126
        """Conflicting contents for newly added file."""
159
 
        other_contents(filename + ".OTHER", self, False)
 
127
        other.contents.apply(filename + ".OTHER")
160
128
        self.conflict("Conflict in newly added file %s" % filename)
161
129
    
162
130
 
227
195
 
228
196
    def finalize(self):
229
197
        if not self.ignore_zero:
230
 
            note("%d conflicts encountered." % self.conflicts)
 
198
            note("%d conflicts encountered.\n" % self.conflicts)
231
199
            
232
200
def get_tree(treespec, local_branch=None):
233
201
    location, revno = treespec
234
 
    branch = Branch.open_containing(location)[0]
 
202
    branch = Branch.open_containing(location)
235
203
    if revno is None:
236
204
        revision = None
237
205
    elif revno == -1:
238
206
        revision = branch.last_revision()
239
207
    else:
240
208
        revision = branch.get_rev_id(revno)
241
 
        if revision is None:
242
 
            revision = NULL_REVISION
243
209
    return branch, get_revid_tree(branch, revision, local_branch)
244
210
 
245
211
def get_revid_tree(branch, revision, local_branch):
268
234
    eventually be done by just building the tree directly calling into 
269
235
    lower-level code (e.g. constructing a changeset).
270
236
    """
271
 
    # RBC 20051019 is this not just 'export' ?
272
 
    # AB Well, export doesn't take care of inventory...
273
 
    this_branch = Branch.open_containing(to_dir)[0]
274
 
    transform_tree(this_branch.working_tree(), this_branch.basis_tree())
275
 
 
276
 
 
277
 
def transform_tree(from_tree, to_tree, interesting_ids=None):
278
 
    merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
279
 
                interesting_ids=interesting_ids)
 
237
    merge((to_dir, -1), (to_dir, 0), this_dir=to_dir,
 
238
          check_clean=False, ignore_zero=True)
280
239
 
281
240
 
282
241
def merge(other_revision, base_revision,
283
242
          check_clean=True, ignore_zero=False,
284
243
          this_dir=None, backup_files=False, merge_type=ApplyMerge3,
285
 
          file_list=None, show_base=False, reprocess=False):
 
244
          file_list=None):
286
245
    """Merge changes into a tree.
287
246
 
288
247
    base_revision
289
 
        list(path, revno) Base for three-way merge.  
290
 
        If [None, None] then a base will be automatically determined.
 
248
        tuple(path, revision) Base for three-way merge.
291
249
    other_revision
292
 
        list(path, revno) Other revision for three-way merge.
 
250
        tuple(path, revision) Other revision for three-way merge.
293
251
    this_dir
294
252
        Directory to merge changes into; '.' by default.
295
253
    check_clean
298
256
    ignore_zero - If true, suppress the "zero conflicts" message when 
299
257
        there are no conflicts; should be set when doing something we expect
300
258
        to complete perfectly.
301
 
    file_list - If supplied, merge only changes to selected files.
302
259
 
303
260
    All available ancestors of other_revision and base_revision are
304
261
    automatically pulled into the branch.
305
 
 
306
 
    The revno may be -1 to indicate the last revision on the branch, which is
307
 
    the typical case.
308
 
 
309
 
    This function is intended for use from the command line; programmatic
310
 
    clients might prefer to call merge_inner(), which has less magic behavior.
311
262
    """
312
 
    if this_dir is None:
313
 
        this_dir = u'.'
314
 
    this_branch = Branch.open_containing(this_dir)[0]
315
 
    if show_base and not merge_type is ApplyMerge3:
316
 
        raise BzrCommandError("Show-base is not supported for this merge"
317
 
                              " type. %s" % merge_type)
318
 
    if reprocess and not merge_type is ApplyMerge3:
319
 
        raise BzrCommandError("Reprocess is not supported for this merge"
320
 
                              " type. %s" % merge_type)
321
 
    if reprocess and show_base:
322
 
        raise BzrCommandError("Cannot reprocess and show base.")
323
 
    merger = Merger(this_branch)
324
 
    merger.check_basis(check_clean)
325
 
    merger.set_other(other_revision)
326
 
    merger.set_base(base_revision)
327
 
    if merger.base_rev_id == merger.other_rev_id:
328
 
        note('Nothing to do.')
329
 
        return 0
330
 
    merger.backup_files = backup_files
331
 
    merger.merge_type = merge_type 
332
 
    merger.set_interesting_files(file_list)
333
 
    merger.show_base = show_base 
334
 
    merger.reprocess = reprocess
335
 
    merger.conflict_handler = MergeConflictHandler(merger.this_tree, 
336
 
                                                   merger.base_tree, 
337
 
                                                   merger.other_tree,
338
 
                                                   ignore_zero=ignore_zero)
339
 
    conflicts = merger.do_merge()
340
 
    merger.set_pending()
341
 
    return conflicts
342
 
 
343
 
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
344
 
                backup_files=False, 
345
 
                merge_type=ApplyMerge3, 
346
 
                interesting_ids=None, 
347
 
                show_base=False, 
348
 
                reprocess=False, 
349
 
                other_rev_id=None,
350
 
                interesting_files=None):
351
 
    """Primary interface for merging. 
352
 
 
353
 
        typical use is probably 
354
 
        'merge_inner(branch, branch.get_revision_tree(other_revision),
355
 
                     branch.get_revision_tree(base_revision))'
356
 
        """
357
 
    merger = Merger(this_branch, other_tree, base_tree)
358
 
    merger.backup_files = backup_files
359
 
    merger.merge_type = merge_type
360
 
    merger.interesting_ids = interesting_ids
361
 
    if interesting_files:
362
 
        assert not interesting_ids, ('Only supply interesting_ids'
363
 
                                     ' or interesting_files')
364
 
        merger._set_interesting_files(interesting_files)
365
 
    merger.show_base = show_base 
366
 
    merger.reprocess = reprocess
367
 
    merger.conflict_handler = MergeConflictHandler(merger.this_tree, base_tree, 
368
 
                                                   other_tree,
369
 
                                                   ignore_zero=ignore_zero)
370
 
    merger.other_rev_id = other_rev_id
371
 
    merger.other_basis = other_rev_id
372
 
    return merger.do_merge()
373
 
 
374
 
 
375
 
class Merger(object):
376
 
    def __init__(self, this_branch, other_tree=None, base_tree=None):
377
 
        object.__init__(self)
378
 
        self.this_branch = this_branch
379
 
        self.this_basis = this_branch.last_revision()
380
 
        self.this_rev_id = None
381
 
        self.this_tree = this_branch.working_tree()
382
 
        self.this_revision_tree = None
383
 
        self.this_basis_tree = None
384
 
        self.other_tree = other_tree
385
 
        self.base_tree = base_tree
386
 
        self.ignore_zero = False
387
 
        self.backup_files = False
388
 
        self.interesting_ids = None
389
 
        self.show_base = False
390
 
        self.reprocess = False
391
 
        self.conflict_handler = MergeConflictHandler(self.this_tree, base_tree, 
392
 
                                                     other_tree)
393
 
 
394
 
    def revision_tree(self, revision_id):
395
 
        return self.this_branch.revision_tree(revision_id)
396
 
 
397
 
    def ensure_revision_trees(self):
398
 
        if self.this_revision_tree is None:
399
 
            self.this_basis_tree = self.this_branch.revision_tree(
400
 
                self.this_basis)
401
 
            if self.this_basis == self.this_rev_id:
402
 
                self.this_revision_tree = self.this_basis_tree
403
 
 
404
 
 
405
 
        if self.other_rev_id is None:
406
 
            other_basis_tree = self.revision_tree(self.other_basis)
407
 
            changes = compare_trees(self.other_tree, other_basis_tree)
408
 
            if changes.has_changed():
409
 
                raise WorkingTreeNotRevision(self.this_tree)
410
 
            other_rev_id = other_basis
411
 
            self.other_tree = other_basis_tree
412
 
 
413
 
 
414
 
    def file_revisions(self, file_id):
415
 
        self.ensure_revision_trees()
416
 
        def get_id(tree, file_id):
417
 
            revision_id = tree.inventory[file_id].revision
418
 
            assert revision_id is not None
419
 
            return revision_id
420
 
        if self.this_rev_id is None:
421
 
            if self.this_basis_tree.get_file_sha1(file_id) != \
422
 
                self.this_tree.get_file_sha1(file_id):
423
 
                raise WorkingTreeNotRevision(self.this_tree)
424
 
 
425
 
        trees = (self.this_basis_tree, self.other_tree)
426
 
        return [get_id(tree, file_id) for tree in trees]
427
 
            
428
 
 
429
 
    def merge_factory(self, file_id, base, other):
430
 
        if self.merge_type.history_based:
431
 
            if self.show_base is True:
432
 
                raise BzrError("Cannot show base for hisory-based merges")
433
 
            if self.reprocess is True:
434
 
                raise BzrError("Cannot reprocess history-based merges")
435
 
                
436
 
            t_revid, o_revid = self.file_revisions(file_id)
437
 
            weave = self.this_basis_tree.get_weave(file_id)
438
 
            contents_change = self.merge_type(weave, t_revid, o_revid)
439
 
        else:
440
 
            if self.show_base is True or self.reprocess is True:
441
 
                contents_change = self.merge_type(file_id, base, other, 
442
 
                                                  show_base=self.show_base, 
443
 
                                                  reprocess=self.reprocess)
444
 
            else:
445
 
                contents_change = self.merge_type(file_id, base, other)
446
 
        if self.backup_files:
447
 
            contents_change = BackupBeforeChange(contents_change)
448
 
        return contents_change
449
 
 
450
 
    def check_basis(self, check_clean):
451
 
        if self.this_basis is None:
 
263
    tempdir = tempfile.mkdtemp(prefix="bzr-")
 
264
    try:
 
265
        if this_dir is None:
 
266
            this_dir = '.'
 
267
        this_branch = Branch.open_containing(this_dir)
 
268
        this_rev_id = this_branch.last_revision()
 
269
        if this_rev_id is None:
452
270
            raise BzrCommandError("This branch has no commits")
453
271
        if check_clean:
454
 
            self.compare_basis()
455
 
            if self.this_basis != self.this_rev_id:
 
272
            changes = compare_trees(this_branch.working_tree(), 
 
273
                                    this_branch.basis_tree(), False)
 
274
            if changes.has_changed():
456
275
                raise BzrCommandError("Working tree has uncommitted changes.")
457
 
 
458
 
    def compare_basis(self):
459
 
        changes = compare_trees(self.this_branch.working_tree(), 
460
 
                                self.this_branch.basis_tree(), False)
461
 
        if not changes.has_changed():
462
 
            self.this_rev_id = self.this_basis
463
 
 
464
 
    def set_interesting_files(self, file_list):
465
 
        try:
466
 
            self._set_interesting_files(file_list)
467
 
        except NotVersionedError, e:
468
 
            raise BzrCommandError("%s is not a source file in any"
469
 
                                      " tree." % e.path)
470
 
 
471
 
    def _set_interesting_files(self, file_list):
472
 
        """Set the list of interesting ids from a list of files."""
473
 
        if file_list is None:
474
 
            self.interesting_ids = None
475
 
            return
476
 
 
477
 
        interesting_ids = set()
478
 
        for fname in file_list:
479
 
            path = self.this_tree.relpath(fname)
480
 
            found_id = False
481
 
            for tree in (self.this_tree, self.base_tree, self.other_tree):
482
 
                file_id = tree.inventory.path2id(path)
483
 
                if file_id is not None:
484
 
                    interesting_ids.add(file_id)
485
 
                    found_id = True
486
 
            if not found_id:
487
 
                raise NotVersionedError(path=fname)
488
 
        self.interesting_ids = interesting_ids
489
 
 
490
 
    def set_pending(self):
491
 
        if not self.base_is_ancestor:
492
 
            return
493
 
        if self.other_rev_id is None:
494
 
            return
495
 
        if self.other_rev_id in self.this_branch.get_ancestry(self.this_basis):
496
 
            return
497
 
        self.this_branch.working_tree().add_pending_merge(self.other_rev_id)
498
 
 
499
 
    def set_other(self, other_revision):
500
 
        other_branch, self.other_tree = get_tree(other_revision, 
501
 
                                                 self.this_branch)
 
276
        other_branch, other_tree = get_tree(other_revision, this_branch)
502
277
        if other_revision[1] == -1:
503
 
            self.other_rev_id = other_branch.last_revision()
504
 
            if self.other_rev_id is None:
 
278
            other_rev_id = other_branch.last_revision()
 
279
            if other_rev_id is None:
505
280
                raise NoCommits(other_branch)
506
 
            self.other_basis = self.other_rev_id
 
281
            other_basis = other_rev_id
507
282
        elif other_revision[1] is not None:
508
 
            self.other_rev_id = other_branch.get_rev_id(other_revision[1])
509
 
            self.other_basis = self.other_rev_id
 
283
            other_rev_id = other_branch.get_rev_id(other_revision[1])
 
284
            other_basis = other_rev_id
510
285
        else:
511
 
            self.other_rev_id = None
512
 
            self.other_basis = other_branch.last_revision()
513
 
            if self.other_basis is None:
 
286
            other_rev_id = None
 
287
            other_basis = other_branch.last_revision()
 
288
            if other_basis is None:
514
289
                raise NoCommits(other_branch)
515
 
        fetch(from_branch=other_branch, to_branch=self.this_branch, 
516
 
              last_revision=self.other_basis)
517
 
 
518
 
    def set_base(self, base_revision):
519
 
        mutter("doing merge() with no base_revision specified")
520
290
        if base_revision == [None, None]:
521
291
            try:
522
 
                self.base_rev_id = common_ancestor(self.this_basis, 
523
 
                                                   self.other_basis, 
524
 
                                                   self.this_branch)
 
292
                base_rev_id = common_ancestor(this_rev_id, other_basis, 
 
293
                                              this_branch)
525
294
            except NoCommonAncestor:
526
295
                raise UnrelatedBranches()
527
 
            self.base_tree = get_revid_tree(self.this_branch, self.base_rev_id,
528
 
                                            None)
529
 
            self.base_is_ancestor = True
 
296
            base_tree = get_revid_tree(this_branch, base_rev_id, None)
 
297
            base_is_ancestor = True
530
298
        else:
531
 
            base_branch, self.base_tree = get_tree(base_revision)
 
299
            base_branch, base_tree = get_tree(base_revision)
532
300
            if base_revision[1] == -1:
533
 
                self.base_rev_id = base_branch.last_revision()
 
301
                base_rev_id = base_branch.last_revision()
534
302
            elif base_revision[1] is None:
535
 
                self.base_rev_id = None
536
 
            else:
537
 
                self.base_rev_id = base_branch.get_rev_id(base_revision[1])
538
 
            fetch(from_branch=base_branch, to_branch=self.this_branch)
539
 
            self.base_is_ancestor = is_ancestor(self.this_basis, 
540
 
                                                self.base_rev_id,
541
 
                                                self.this_branch)
542
 
 
543
 
    def do_merge(self):
544
 
        def get_inventory(tree):
545
 
            return tree.inventory
546
 
        
547
 
        inv_changes = merge_flex(self.this_tree, self.base_tree, 
548
 
                                 self.other_tree,
549
 
                                 generate_changeset, get_inventory,
550
 
                                 self.conflict_handler,
551
 
                                 merge_factory=self.merge_factory, 
552
 
                                 interesting_ids=self.interesting_ids)
553
 
 
554
 
        adjust_ids = []
555
 
        for id, path in inv_changes.iteritems():
556
 
            if path is not None:
557
 
                if path == u'.':
558
 
                    path = u''
559
 
                else:
560
 
                    assert path.startswith('.' + '/') or path.startswith('.' + '\\'), "path is %s" % path
561
 
                path = path[2:]
562
 
            adjust_ids.append((path, id))
563
 
        if len(adjust_ids) > 0:
564
 
            self.this_branch.working_tree().set_inventory(self.regen_inventory(adjust_ids))
565
 
        conflicts = self.conflict_handler.conflicts
566
 
        self.conflict_handler.finalize()
567
 
        return conflicts
568
 
 
569
 
    def regen_inventory(self, new_entries):
570
 
        old_entries = self.this_branch.working_tree().read_working_inventory()
571
 
        new_inventory = {}
572
 
        by_path = {}
573
 
        new_entries_map = {} 
574
 
        for path, file_id in new_entries:
575
 
            if path is None:
576
 
                continue
577
 
            new_entries_map[file_id] = path
578
 
 
579
 
        def id2path(file_id):
580
 
            path = new_entries_map.get(file_id)
581
 
            if path is not None:
582
 
                return path
583
 
            entry = old_entries[file_id]
584
 
            if entry.parent_id is None:
585
 
                return entry.name
586
 
            return os.path.join(id2path(entry.parent_id), entry.name)
587
 
            
588
 
        for file_id in old_entries:
589
 
            entry = old_entries[file_id]
590
 
            path = id2path(file_id)
591
 
            new_inventory[file_id] = (path, file_id, entry.parent_id, 
592
 
                                      entry.kind)
593
 
            by_path[path] = file_id
594
 
        
595
 
        deletions = 0
596
 
        insertions = 0
597
 
        new_path_list = []
598
 
        for path, file_id in new_entries:
599
 
            if path is None:
600
 
                del new_inventory[file_id]
601
 
                deletions += 1
602
 
            else:
603
 
                new_path_list.append((path, file_id))
604
 
                if file_id not in old_entries:
605
 
                    insertions += 1
606
 
        # Ensure no file is added before its parent
607
 
        new_path_list.sort()
608
 
        for path, file_id in new_path_list:
609
 
            if path == '':
610
 
                parent = None
611
 
            else:
612
 
                parent = by_path[os.path.dirname(path)]
613
 
            abspath = os.path.join(self.this_tree.basedir, path)
614
 
            kind = bzrlib.osutils.file_kind(abspath)
615
 
            new_inventory[file_id] = (path, file_id, parent, kind)
616
 
            by_path[path] = file_id 
617
 
 
618
 
        # Get a list in insertion order
619
 
        new_inventory_list = new_inventory.values()
620
 
        mutter ("""Inventory regeneration:
621
 
    old length: %i insertions: %i deletions: %i new_length: %i"""\
622
 
            % (len(old_entries), insertions, deletions, 
623
 
               len(new_inventory_list)))
624
 
        assert len(new_inventory_list) == len(old_entries) + insertions\
625
 
            - deletions
626
 
        new_inventory_list.sort()
627
 
        return new_inventory_list
 
303
                base_rev_id = None
 
304
            else:
 
305
                base_rev_id = base_branch.get_rev_id(base_revision[1])
 
306
            fetch(from_branch=base_branch, to_branch=this_branch)
 
307
            base_is_ancestor = is_ancestor(this_rev_id, base_rev_id,
 
308
                                           this_branch)
 
309
        if file_list is None:
 
310
            interesting_ids = None
 
311
        else:
 
312
            interesting_ids = set()
 
313
            this_tree = this_branch.working_tree()
 
314
            for fname in file_list:
 
315
                path = this_tree.relpath(fname)
 
316
                found_id = False
 
317
                for tree in (this_tree, base_tree, other_tree):
 
318
                    file_id = tree.inventory.path2id(path)
 
319
                    if file_id is not None:
 
320
                        interesting_ids.add(file_id)
 
321
                        found_id = True
 
322
                if not found_id:
 
323
                    raise BzrCommandError("%s is not a source file in any"
 
324
                                          " tree." % fname)
 
325
        merge_inner(this_branch, other_tree, base_tree, tempdir, 
 
326
                    ignore_zero=ignore_zero, backup_files=backup_files, 
 
327
                    merge_type=merge_type, interesting_ids=interesting_ids)
 
328
        if base_is_ancestor and other_rev_id is not None\
 
329
            and other_rev_id not in this_branch.revision_history():
 
330
            this_branch.add_pending_merge(other_rev_id)
 
331
    finally:
 
332
        shutil.rmtree(tempdir)
 
333
 
 
334
 
 
335
def set_interesting(inventory_a, inventory_b, interesting_ids):
 
336
    """Mark files whose ids are in interesting_ids as interesting
 
337
    """
 
338
    for inventory in (inventory_a, inventory_b):
 
339
        for path, source_file in inventory.iteritems():
 
340
             source_file.interesting = source_file.id in interesting_ids
 
341
 
 
342
 
 
343
def merge_inner(this_branch, other_tree, base_tree, tempdir, 
 
344
                ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
 
345
                interesting_ids=None):
 
346
 
 
347
    def merge_factory(file_id, base, other):
 
348
        contents_change = merge_type(file_id, base, other)
 
349
        if backup_files:
 
350
            contents_change = BackupBeforeChange(contents_change)
 
351
        return contents_change
 
352
 
 
353
    this_tree = get_tree((this_branch.base, None))[1]
 
354
 
 
355
    def get_inventory(tree):
 
356
        return tree.inventory
 
357
 
 
358
    inv_changes = merge_flex(this_tree, base_tree, other_tree,
 
359
                             generate_changeset, get_inventory,
 
360
                             MergeConflictHandler(this_tree, base_tree,
 
361
                             other_tree, ignore_zero=ignore_zero),
 
362
                             merge_factory=merge_factory, 
 
363
                             interesting_ids=interesting_ids)
 
364
 
 
365
    adjust_ids = []
 
366
    for id, path in inv_changes.iteritems():
 
367
        if path is not None:
 
368
            if path == '.':
 
369
                path = ''
 
370
            else:
 
371
                assert path.startswith('.' + os.sep), "path is %s" % path
 
372
            path = path[2:]
 
373
        adjust_ids.append((path, id))
 
374
    if len(adjust_ids) > 0:
 
375
        this_branch.set_inventory(regen_inventory(this_branch, 
 
376
                                                  this_tree.basedir,
 
377
                                                  adjust_ids))
 
378
 
 
379
 
 
380
def regen_inventory(this_branch, root, new_entries):
 
381
    old_entries = this_branch.read_working_inventory()
 
382
    new_inventory = {}
 
383
    by_path = {}
 
384
    new_entries_map = {} 
 
385
    for path, file_id in new_entries:
 
386
        if path is None:
 
387
            continue
 
388
        new_entries_map[file_id] = path
 
389
 
 
390
    def id2path(file_id):
 
391
        path = new_entries_map.get(file_id)
 
392
        if path is not None:
 
393
            return path
 
394
        entry = old_entries[file_id]
 
395
        if entry.parent_id is None:
 
396
            return entry.name
 
397
        return os.path.join(id2path(entry.parent_id), entry.name)
 
398
        
 
399
    for file_id in old_entries:
 
400
        entry = old_entries[file_id]
 
401
        path = id2path(file_id)
 
402
        new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
 
403
        by_path[path] = file_id
 
404
    
 
405
    deletions = 0
 
406
    insertions = 0
 
407
    new_path_list = []
 
408
    for path, file_id in new_entries:
 
409
        if path is None:
 
410
            del new_inventory[file_id]
 
411
            deletions += 1
 
412
        else:
 
413
            new_path_list.append((path, file_id))
 
414
            if file_id not in old_entries:
 
415
                insertions += 1
 
416
    # Ensure no file is added before its parent
 
417
    new_path_list.sort()
 
418
    for path, file_id in new_path_list:
 
419
        if path == '':
 
420
            parent = None
 
421
        else:
 
422
            parent = by_path[os.path.dirname(path)]
 
423
        kind = bzrlib.osutils.file_kind(os.path.join(root, path))
 
424
        new_inventory[file_id] = (path, file_id, parent, kind)
 
425
        by_path[path] = file_id 
 
426
 
 
427
    # Get a list in insertion order
 
428
    new_inventory_list = new_inventory.values()
 
429
    mutter ("""Inventory regeneration:
 
430
old length: %i insertions: %i deletions: %i new_length: %i"""\
 
431
        % (len(old_entries), insertions, deletions, len(new_inventory_list)))
 
432
    assert len(new_inventory_list) == len(old_entries) + insertions - deletions
 
433
    new_inventory_list.sort()
 
434
    return new_inventory_list
628
435
 
629
436
merge_types = {     "merge3": (ApplyMerge3, "Native diff3-style merge"), 
630
 
                     "diff3": (Diff3Merge,  "Merge using external diff3"),
631
 
                     'weave': (WeaveMerge, "Weave-based merge")
 
437
                     "diff3": (Diff3Merge,  "Merge using external diff3")
632
438
              }
633
439