← 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-08 08:45:42 UTC
  • Revision ID: robertc@robertcollins.net-20051008084542-48ea5a99756f970e
add rm alias to remove

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
 
from merge_core import merge_flex
2
 
from changeset import generate_changeset, ExceptionConflictHandler
3
 
from changeset import Inventory
4
 
from bzrlib import find_branch
5
 
import bzrlib.osutils
6
 
from bzrlib.errors import BzrCommandError
7
 
from bzrlib.diff import compare_trees
8
 
from trace import mutter, warning
9
 
import os.path
 
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
10
19
import tempfile
11
20
import shutil
12
21
import errno
13
22
 
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
 
 
 
23
import bzrlib.osutils
 
24
import bzrlib.revision
 
25
from bzrlib.merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
 
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, UnrelatedBranches, NoCommonAncestor
 
30
from bzrlib.errors import NoCommits
 
31
from bzrlib.delta import compare_trees
 
32
from bzrlib.trace import mutter, warning
 
33
from bzrlib.fetch import greedy_fetch, fetch
 
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
 
 
43
# comments from abentley on irc: merge happens in two stages, each
 
44
# of which generates a changeset object
 
45
 
 
46
# stage 1: generate OLD->OTHER,
 
47
# stage 2: use MINE and OLD->OTHER to generate MINE -> RESULT
20
48
 
21
49
class MergeConflictHandler(ExceptionConflictHandler):
22
 
    """Handle conflicts encountered while merging"""
23
 
    def __init__(self, dir, ignore_zero=False):
24
 
        ExceptionConflictHandler.__init__(self, dir)
 
50
    """Handle conflicts encountered while merging.
 
51
 
 
52
    This subclasses ExceptionConflictHandler, so that any types of
 
53
    conflict that are not explicitly handled cause an exception and
 
54
    terminate the merge.
 
55
    """
 
56
    def __init__(self, this_tree, base_tree, other_tree, ignore_zero=False):
 
57
        ExceptionConflictHandler.__init__(self)
25
58
        self.conflicts = 0
26
59
        self.ignore_zero = ignore_zero
 
60
        self.this_tree = this_tree
 
61
        self.base_tree = base_tree
 
62
        self.other_tree = other_tree
27
63
 
28
64
    def copy(self, source, dest):
29
65
        """Copy the text and mode of a file
36
72
            d_file.write(line)
37
73
        os.chmod(dest, 0777 & os.stat(source).st_mode)
38
74
 
 
75
    def dump(self, lines, dest):
 
76
        """Copy the text and mode of a file
 
77
        :param source: The path of the file to copy
 
78
        :param dest: The distination file to create
 
79
        """
 
80
        d_file = file(dest, "wb")
 
81
        for line in lines:
 
82
            d_file.write(line)
 
83
 
39
84
    def add_suffix(self, name, suffix, last_new_name=None):
40
85
        """Rename a file to append a suffix.  If the new name exists, the
41
86
        suffix is added repeatedly until a non-existant name is found
48
93
            last_new_name = name
49
94
        new_name = last_new_name+suffix
50
95
        try:
51
 
            os.rename(name, new_name)
 
96
            rename(name, new_name)
52
97
            return new_name
53
98
        except OSError, e:
54
99
            if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
60
105
        self.conflicts += 1
61
106
        
62
107
 
63
 
    def merge_conflict(self, new_file, this_path, base_path, other_path):
 
108
    def merge_conflict(self, new_file, this_path, base_lines, other_lines):
64
109
        """
65
110
        Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER.  The
66
111
        main file will be a version with diff3 conflicts.
70
115
        :param other_path: Path to the file text for the OTHER tree
71
116
        """
72
117
        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)
 
118
        self.dump(base_lines, this_path+".BASE")
 
119
        self.dump(other_lines, this_path+".OTHER")
 
120
        rename(new_file, this_path)
76
121
        self.conflict("Diff3 conflict encountered in %s" % this_path)
77
122
 
 
123
    def new_contents_conflict(self, filename, other_contents):
 
124
        """Conflicting contents for newly added file."""
 
125
        self.copy(other_contents, filename + ".OTHER")
 
126
        self.conflict("Conflict in newly added file %s" % filename)
 
127
    
 
128
 
78
129
    def target_exists(self, entry, target, old_path):
79
130
        """Handle the case when the target file or dir exists"""
80
131
        moved_path = self.add_suffix(target, ".moved")
86
137
            % filename)
87
138
        return "skip"
88
139
 
 
140
    def rem_contents_conflict(self, filename, this_contents, base_contents):
 
141
        base_contents(filename+".BASE", self, False)
 
142
        this_contents(filename+".THIS", self, False)
 
143
        return ReplaceContents(this_contents, None)
 
144
 
 
145
    def rem_contents_conflict(self, filename, this_contents, base_contents):
 
146
        base_contents(filename+".BASE", self, False)
 
147
        this_contents(filename+".THIS", self, False)
 
148
        self.conflict("Other branch deleted locally modified file %s" %
 
149
                      filename)
 
150
        return ReplaceContents(this_contents, None)
 
151
 
 
152
    def abs_this_path(self, file_id):
 
153
        """Return the absolute path for a file_id in the this tree."""
 
154
        relpath = self.this_tree.id2path(file_id)
 
155
        return self.this_tree.tree.abspath(relpath)
 
156
 
 
157
    def add_missing_parents(self, file_id, tree):
 
158
        """If some of the parents for file_id are missing, add them."""
 
159
        entry = tree.tree.inventory[file_id]
 
160
        if entry.parent_id not in self.this_tree:
 
161
            return self.create_all_missing(entry.parent_id, tree)
 
162
        else:
 
163
            return self.abs_this_path(entry.parent_id)
 
164
 
 
165
    def create_all_missing(self, file_id, tree):
 
166
        """Add contents for a file_id and all its parents to a tree."""
 
167
        entry = tree.tree.inventory[file_id]
 
168
        if entry.parent_id is not None and entry.parent_id not in self.this_tree:
 
169
            abspath = self.create_all_missing(entry.parent_id, tree)
 
170
        else:
 
171
            abspath = self.abs_this_path(entry.parent_id)
 
172
        entry_path = os.path.join(abspath, entry.name)
 
173
        if not os.path.isdir(entry_path):
 
174
            self.create(file_id, entry_path, tree)
 
175
        return entry_path
 
176
 
 
177
    def create(self, file_id, path, tree, reverse=False):
 
178
        """Uses tree data to create a filesystem object for the file_id"""
 
179
        from merge_core import get_id_contents
 
180
        get_id_contents(file_id, tree)(path, self, reverse)
 
181
 
 
182
    def missing_for_merge(self, file_id, other_path):
 
183
        """The file_id doesn't exist in THIS, but does in OTHER and BASE"""
 
184
        self.conflict("Other branch modified locally deleted file %s" %
 
185
                      other_path)
 
186
        parent_dir = self.add_missing_parents(file_id, self.other_tree)
 
187
        stem = os.path.join(parent_dir, os.path.basename(other_path))
 
188
        self.create(file_id, stem+".OTHER", self.other_tree)
 
189
        self.create(file_id, stem+".BASE", self.base_tree)
 
190
 
89
191
    def finalize(self):
90
192
        if not self.ignore_zero:
91
193
            print "%d conflicts encountered.\n" % self.conflicts
92
194
            
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):
 
195
def get_tree(treespec, temp_root, label, local_branch=None):
105
196
    location, revno = treespec
106
 
    branch = find_branch(location)
 
197
    branch = Branch.open_containing(location)
107
198
    if revno is None:
 
199
        revision = None
 
200
    elif revno == -1:
 
201
        revision = branch.last_revision()
 
202
    else:
 
203
        revision = branch.get_rev_id(revno)
 
204
    return branch, get_revid_tree(branch, revision, temp_root, label,
 
205
                                  local_branch)
 
206
 
 
207
def get_revid_tree(branch, revision, temp_root, label, local_branch):
 
208
    if revision is None:
108
209
        base_tree = branch.working_tree()
109
 
    elif revno == -1:
110
 
        base_tree = branch.basis_tree()
111
210
    else:
112
 
        base_tree = branch.revision_tree(branch.lookup_revision(revno))
 
211
        if local_branch is not None:
 
212
            greedy_fetch(local_branch, branch, revision)
 
213
            base_tree = local_branch.revision_tree(revision)
 
214
        else:
 
215
            base_tree = branch.revision_tree(revision)
113
216
    temp_path = os.path.join(temp_root, label)
114
217
    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
 
218
    return MergeTree(base_tree, temp_path)
 
219
 
123
220
 
124
221
def file_exists(tree, file_id):
125
222
    return tree.has_filename(tree.id2path(file_id))
126
223
    
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
224
 
135
225
class MergeTree(object):
136
226
    def __init__(self, tree, tempdir):
139
229
            self.root = tree.basedir
140
230
        else:
141
231
            self.root = None
142
 
        self.inventory = inventory_map(tree)
143
232
        self.tree = tree
144
233
        self.tempdir = tempdir
145
234
        os.mkdir(os.path.join(self.tempdir, "texts"))
 
235
        os.mkdir(os.path.join(self.tempdir, "symlinks"))
146
236
        self.cached = {}
147
237
 
 
238
    def __iter__(self):
 
239
        return self.tree.__iter__()
 
240
 
 
241
    def __contains__(self, file_id):
 
242
        return file_id in self.tree
 
243
 
 
244
    def get_file(self, file_id):
 
245
        return self.tree.get_file(file_id)
 
246
 
 
247
    def get_file_sha1(self, id):
 
248
        return self.tree.get_file_sha1(id)
 
249
 
 
250
    def is_executable(self, id):
 
251
        return self.tree.is_executable(id)
 
252
 
 
253
    def id2path(self, file_id):
 
254
        return self.tree.id2path(file_id)
 
255
 
 
256
    def has_id(self, file_id):
 
257
        return self.tree.has_id(file_id)
 
258
 
 
259
    def has_or_had_id(self, file_id):
 
260
        if file_id == self.tree.inventory.root.file_id:
 
261
            return True
 
262
        return self.tree.inventory.has_id(file_id)
 
263
 
 
264
    def has_or_had_id(self, file_id):
 
265
        if file_id == self.tree.inventory.root.file_id:
 
266
            return True
 
267
        return self.tree.inventory.has_id(file_id)
 
268
 
148
269
    def readonly_path(self, id):
149
270
        if id not in self.tree:
150
271
            return None
151
272
        if self.root is not None:
152
273
            return self.tree.abspath(self.tree.id2path(id))
153
274
        else:
154
 
            if self.tree.inventory[id].kind in ("directory", "root_directory"):
 
275
            kind = self.tree.inventory[id].kind
 
276
            if kind in ("directory", "root_directory"):
155
277
                return self.tempdir
156
278
            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))
 
279
                if kind == "file":
 
280
                    path = os.path.join(self.tempdir, "texts", id)
 
281
                    outfile = file(path, "wb")
 
282
                    outfile.write(self.tree.get_file(id).read())
 
283
                    assert(bzrlib.osutils.lexists(path))
 
284
                    if self.tree.is_executable(id):
 
285
                        os.chmod(path, 0755)
 
286
                else:
 
287
                    assert kind == "symlink"
 
288
                    path = os.path.join(self.tempdir, "symlinks", id)
 
289
                    target = self.tree.get_symlink_target(id)
 
290
                    os.symlink(target, path)
161
291
                self.cached[id] = path
162
292
            return self.cached[id]
163
293
 
164
294
 
 
295
def build_working_dir(to_dir):
 
296
    """Build a working directory in an empty directory.
 
297
 
 
298
    to_dir is a directory containing branch metadata but no working files,
 
299
    typically constructed by cloning an existing branch. 
 
300
 
 
301
    This is split out as a special idiomatic case of merge.  It could
 
302
    eventually be done by just building the tree directly calling into 
 
303
    lower-level code (e.g. constructing a changeset).
 
304
    """
 
305
    merge((to_dir, -1), (to_dir, 0), this_dir=to_dir,
 
306
          check_clean=False, ignore_zero=True)
 
307
 
165
308
 
166
309
def merge(other_revision, base_revision,
167
310
          check_clean=True, ignore_zero=False,
168
 
          this_dir=None):
 
311
          this_dir=None, backup_files=False, merge_type=ApplyMerge3,
 
312
          file_list=None):
169
313
    """Merge changes into a tree.
170
314
 
171
315
    base_revision
172
 
        Base for three-way merge.
 
316
        tuple(path, revision) Base for three-way merge.
173
317
    other_revision
174
 
        Other revision for three-way merge.
 
318
        tuple(path, revision) Other revision for three-way merge.
175
319
    this_dir
176
320
        Directory to merge changes into; '.' by default.
177
321
    check_clean
178
322
        If true, this_dir must have no uncommitted changes before the
179
323
        merge begins.
 
324
    ignore_zero - If true, suppress the "zero conflicts" message when 
 
325
        there are no conflicts; should be set when doing something we expect
 
326
        to complete perfectly.
 
327
 
 
328
    All available ancestors of other_revision and base_revision are
 
329
    automatically pulled into the branch.
180
330
    """
181
331
    tempdir = tempfile.mkdtemp(prefix="bzr-")
182
332
    try:
183
333
        if this_dir is None:
184
334
            this_dir = '.'
185
 
        this_branch = find_branch(this_dir)
 
335
        this_branch = Branch.open_containing(this_dir)
 
336
        this_rev_id = this_branch.last_revision()
 
337
        if this_rev_id is None:
 
338
            raise BzrCommandError("This branch has no commits")
186
339
        if check_clean:
187
340
            changes = compare_trees(this_branch.working_tree(), 
188
341
                                    this_branch.basis_tree(), False)
189
342
            if changes.has_changed():
190
343
                raise BzrCommandError("Working tree has uncommitted changes.")
191
 
        other_branch, other_tree = get_tree(other_revision, tempdir, "other")
 
344
        other_branch, other_tree = get_tree(other_revision, tempdir, "other",
 
345
                                            this_branch)
 
346
        if other_revision[1] == -1:
 
347
            other_rev_id = other_branch.last_revision()
 
348
            if other_rev_id is None:
 
349
                raise NoCommits(other_branch)
 
350
            other_basis = other_rev_id
 
351
        elif other_revision[1] is not None:
 
352
            other_rev_id = other_branch.get_rev_id(other_revision[1])
 
353
            other_basis = other_rev_id
 
354
        else:
 
355
            other_rev_id = None
 
356
            other_basis = other_branch.last_revision()
 
357
            if other_basis is None:
 
358
                raise NoCommits(other_branch)
192
359
        if base_revision == [None, None]:
193
 
            if other_revision[1] == -1:
194
 
                o_revno = None
195
 
            else:
196
 
                o_revno = other_revision[1]
197
 
            base_revno = this_branch.common_ancestor(other_branch, 
198
 
                                                     other_revno=o_revno)[0]
199
 
            if base_revno is None:
 
360
            try:
 
361
                base_rev_id = common_ancestor(this_rev_id, other_basis, 
 
362
                                              this_branch)
 
363
            except NoCommonAncestor:
200
364
                raise UnrelatedBranches()
201
 
            base_revision = ['.', base_revno]
202
 
        base_branch, base_tree = get_tree(base_revision, tempdir, "base")
 
365
            base_tree = get_revid_tree(this_branch, base_rev_id, tempdir, 
 
366
                                       "base", None)
 
367
            base_is_ancestor = True
 
368
        else:
 
369
            base_branch, base_tree = get_tree(base_revision, tempdir, "base")
 
370
            if base_revision[1] == -1:
 
371
                base_rev_id = base_branch.last_revision()
 
372
            elif base_revision[1] is None:
 
373
                base_rev_id = None
 
374
            else:
 
375
                base_rev_id = base_branch.get_rev_id(base_revision[1])
 
376
            fetch(from_branch=base_branch, to_branch=this_branch)
 
377
            base_is_ancestor = is_ancestor(this_rev_id, base_rev_id,
 
378
                                           this_branch)
 
379
        if file_list is None:
 
380
            interesting_ids = None
 
381
        else:
 
382
            interesting_ids = set()
 
383
            this_tree = this_branch.working_tree()
 
384
            for fname in file_list:
 
385
                path = this_branch.relpath(fname)
 
386
                found_id = False
 
387
                for tree in (this_tree, base_tree.tree, other_tree.tree):
 
388
                    file_id = tree.inventory.path2id(path)
 
389
                    if file_id is not None:
 
390
                        interesting_ids.add(file_id)
 
391
                        found_id = True
 
392
                if not found_id:
 
393
                    raise BzrCommandError("%s is not a source file in any"
 
394
                                          " tree." % fname)
203
395
        merge_inner(this_branch, other_tree, base_tree, tempdir, 
204
 
                    ignore_zero=ignore_zero)
 
396
                    ignore_zero=ignore_zero, backup_files=backup_files, 
 
397
                    merge_type=merge_type, interesting_ids=interesting_ids)
 
398
        if base_is_ancestor and other_rev_id is not None\
 
399
            and other_rev_id not in this_branch.revision_history():
 
400
            this_branch.add_pending_merge(other_rev_id)
205
401
    finally:
206
402
        shutil.rmtree(tempdir)
207
403
 
208
404
 
209
 
def generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b):
210
 
    """Generate a changeset, using the text_id to mark really-changed files.
211
 
    This permits blazing comparisons when text_ids are present.  It also
212
 
    disables metadata comparison for files with identical texts.
 
405
def set_interesting(inventory_a, inventory_b, interesting_ids):
 
406
    """Mark files whose ids are in interesting_ids as interesting
 
407
    """
 
408
    for inventory in (inventory_a, inventory_b):
 
409
        for path, source_file in inventory.iteritems():
 
410
             source_file.interesting = source_file.id in interesting_ids
 
411
 
 
412
 
 
413
def generate_cset_optimized(tree_a, tree_b, interesting_ids=None):
 
414
    """Generate a changeset.  If interesting_ids is supplied, only changes
 
415
    to those files will be shown.  Metadata changes are stripped.
213
416
    """ 
214
 
    for file_id in tree_a.tree.inventory:
215
 
        if file_id not in tree_b.tree.inventory:
216
 
            continue
217
 
        entry_a = tree_a.tree.inventory[file_id]
218
 
        entry_b = tree_b.tree.inventory[file_id]
219
 
        if (entry_a.kind, entry_b.kind) != ("file", "file"):
220
 
            continue
221
 
        if None in (entry_a.text_id, entry_b.text_id):
222
 
            continue
223
 
        if entry_a.text_id != entry_b.text_id:
224
 
            continue
225
 
        inventory_a[abspath(tree_a.tree, file_id)].interesting = False
226
 
        inventory_b[abspath(tree_b.tree, file_id)].interesting = False
227
 
    cset =  generate_changeset(tree_a, tree_b, inventory_a, inventory_b)
 
417
    cset =  generate_changeset(tree_a, tree_b, interesting_ids)
228
418
    for entry in cset.entries.itervalues():
229
419
        entry.metadata_change = None
230
420
    return cset
231
421
 
232
422
 
233
423
def merge_inner(this_branch, other_tree, base_tree, tempdir, 
234
 
                ignore_zero=False):
 
424
                ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
 
425
                interesting_ids=None):
 
426
 
 
427
    def merge_factory(file_id, base, other):
 
428
        contents_change = merge_type(file_id, base, other)
 
429
        if backup_files:
 
430
            contents_change = BackupBeforeChange(contents_change)
 
431
        return contents_change
 
432
 
235
433
    this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
236
434
 
237
435
    def get_inventory(tree):
238
 
        return tree.inventory
 
436
        return tree.tree.inventory
239
437
 
240
438
    inv_changes = merge_flex(this_tree, base_tree, other_tree,
241
439
                             generate_cset_optimized, get_inventory,
242
 
                             MergeConflictHandler(base_tree.root,
243
 
                                                  ignore_zero=ignore_zero))
 
440
                             MergeConflictHandler(this_tree, base_tree,
 
441
                             other_tree, ignore_zero=ignore_zero),
 
442
                             merge_factory=merge_factory, 
 
443
                             interesting_ids=interesting_ids)
244
444
 
245
445
    adjust_ids = []
246
446
    for id, path in inv_changes.iteritems():
248
448
            if path == '.':
249
449
                path = ''
250
450
            else:
251
 
                assert path.startswith('./')
 
451
                assert path.startswith('.' + os.sep), "path is %s" % path
252
452
            path = path[2:]
253
453
        adjust_ids.append((path, id))
254
 
    this_branch.set_inventory(regen_inventory(this_branch, this_tree.root, adjust_ids))
 
454
    if len(adjust_ids) > 0:
 
455
        this_branch.set_inventory(regen_inventory(this_branch, this_tree.root,
 
456
                                                  adjust_ids))
255
457
 
256
458
 
257
459
def regen_inventory(this_branch, root, new_entries):
258
460
    old_entries = this_branch.read_working_inventory()
259
461
    new_inventory = {}
260
462
    by_path = {}
 
463
    new_entries_map = {} 
 
464
    for path, file_id in new_entries:
 
465
        if path is None:
 
466
            continue
 
467
        new_entries_map[file_id] = path
 
468
 
 
469
    def id2path(file_id):
 
470
        path = new_entries_map.get(file_id)
 
471
        if path is not None:
 
472
            return path
 
473
        entry = old_entries[file_id]
 
474
        if entry.parent_id is None:
 
475
            return entry.name
 
476
        return os.path.join(id2path(entry.parent_id), entry.name)
 
477
        
261
478
    for file_id in old_entries:
262
479
        entry = old_entries[file_id]
263
 
        path = old_entries.id2path(file_id)
 
480
        path = id2path(file_id)
264
481
        new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
265
482
        by_path[path] = file_id
266
483
    
294
511
    assert len(new_inventory_list) == len(old_entries) + insertions - deletions
295
512
    new_inventory_list.sort()
296
513
    return new_inventory_list
 
514
 
 
515
merge_types = {     "merge3": (ApplyMerge3, "Native diff3-style merge"), 
 
516
                     "diff3": (Diff3Merge,  "Merge using external diff3")
 
517
              }
 
518