/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: Robert Collins
  • Date: 2005-10-03 05:54:35 UTC
  • mto: (1393.1.30)
  • mto: This revision was merged to the branch mainline in revision 1400.
  • Revision ID: robertc@robertcollins.net-20051003055434-c8ebd30d1de10247
move exporting functionality into inventory.py - uncovers bug in symlink support

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
 
from merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
2
 
from changeset import generate_changeset, ExceptionConflictHandler
3
 
from changeset import Inventory, Diff3Merge
4
 
from bzrlib import find_branch
5
 
import bzrlib.osutils
6
 
from bzrlib.errors import BzrCommandError
7
 
from bzrlib.delta 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
        self.conflict("Other branch deleted locally modified file %s" %
 
144
                      filename)
 
145
        return ReplaceContents(this_contents, None)
 
146
 
 
147
    def abs_this_path(self, file_id):
 
148
        """Return the absolute path for a file_id in the this tree."""
 
149
        relpath = self.this_tree.id2path(file_id)
 
150
        return self.this_tree.tree.abspath(relpath)
 
151
 
 
152
    def add_missing_parents(self, file_id, tree):
 
153
        """If some of the parents for file_id are missing, add them."""
 
154
        entry = tree.tree.inventory[file_id]
 
155
        if entry.parent_id not in self.this_tree:
 
156
            return self.create_all_missing(entry.parent_id, tree)
 
157
        else:
 
158
            return self.abs_this_path(entry.parent_id)
 
159
 
 
160
    def create_all_missing(self, file_id, tree):
 
161
        """Add contents for a file_id and all its parents to a tree."""
 
162
        entry = tree.tree.inventory[file_id]
 
163
        if entry.parent_id is not None and entry.parent_id not in self.this_tree:
 
164
            abspath = self.create_all_missing(entry.parent_id, tree)
 
165
        else:
 
166
            abspath = self.abs_this_path(entry.parent_id)
 
167
        entry_path = os.path.join(abspath, entry.name)
 
168
        if not os.path.isdir(entry_path):
 
169
            self.create(file_id, entry_path, tree)
 
170
        return entry_path
 
171
 
 
172
    def create(self, file_id, path, tree, reverse=False):
 
173
        """Uses tree data to create a filesystem object for the file_id"""
 
174
        from merge_core import get_id_contents
 
175
        get_id_contents(file_id, tree)(path, self, reverse)
 
176
 
 
177
    def missing_for_merge(self, file_id, other_path):
 
178
        """The file_id doesn't exist in THIS, but does in OTHER and BASE"""
 
179
        self.conflict("Other branch modified locally deleted file %s" %
 
180
                      other_path)
 
181
        parent_dir = self.add_missing_parents(file_id, self.other_tree)
 
182
        stem = os.path.join(parent_dir, os.path.basename(other_path))
 
183
        self.create(file_id, stem+".OTHER", self.other_tree)
 
184
        self.create(file_id, stem+".BASE", self.base_tree)
 
185
 
89
186
    def finalize(self):
90
187
        if not self.ignore_zero:
91
188
            print "%d conflicts encountered.\n" % self.conflicts
92
189
            
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):
 
190
def get_tree(treespec, temp_root, label, local_branch=None):
105
191
    location, revno = treespec
106
 
    branch = find_branch(location)
 
192
    branch = Branch.open_containing(location)
107
193
    if revno is None:
 
194
        revision = None
 
195
    elif revno == -1:
 
196
        revision = branch.last_revision()
 
197
    else:
 
198
        revision = branch.get_rev_id(revno)
 
199
    return branch, get_revid_tree(branch, revision, temp_root, label,
 
200
                                  local_branch)
 
201
 
 
202
def get_revid_tree(branch, revision, temp_root, label, local_branch):
 
203
    if revision is None:
108
204
        base_tree = branch.working_tree()
109
 
    elif revno == -1:
110
 
        base_tree = branch.basis_tree()
111
205
    else:
112
 
        base_tree = branch.revision_tree(branch.lookup_revision(revno))
 
206
        if local_branch is not None:
 
207
            greedy_fetch(local_branch, branch, revision)
 
208
            base_tree = local_branch.revision_tree(revision)
 
209
        else:
 
210
            base_tree = branch.revision_tree(revision)
113
211
    temp_path = os.path.join(temp_root, label)
114
212
    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
 
213
    return MergeTree(base_tree, temp_path)
 
214
 
123
215
 
124
216
def file_exists(tree, file_id):
125
217
    return tree.has_filename(tree.id2path(file_id))
126
218
    
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
219
 
135
220
class MergeTree(object):
136
221
    def __init__(self, tree, tempdir):
139
224
            self.root = tree.basedir
140
225
        else:
141
226
            self.root = None
142
 
        self.inventory = inventory_map(tree)
143
227
        self.tree = tree
144
228
        self.tempdir = tempdir
145
229
        os.mkdir(os.path.join(self.tempdir, "texts"))
 
230
        os.mkdir(os.path.join(self.tempdir, "symlinks"))
146
231
        self.cached = {}
147
232
 
 
233
    def __iter__(self):
 
234
        return self.tree.__iter__()
 
235
 
 
236
    def __contains__(self, file_id):
 
237
        return file_id in self.tree
 
238
 
 
239
    def get_file(self, file_id):
 
240
        return self.tree.get_file(file_id)
 
241
 
 
242
    def get_file_sha1(self, id):
 
243
        return self.tree.get_file_sha1(id)
 
244
 
 
245
    def is_executable(self, id):
 
246
        return self.tree.is_executable(id)
 
247
 
 
248
    def id2path(self, file_id):
 
249
        return self.tree.id2path(file_id)
 
250
 
 
251
    def has_id(self, file_id):
 
252
        return self.tree.has_id(file_id)
 
253
 
 
254
    def has_or_had_id(self, file_id):
 
255
        if file_id == self.tree.inventory.root.file_id:
 
256
            return True
 
257
        return self.tree.inventory.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
 
148
264
    def readonly_path(self, id):
149
265
        if id not in self.tree:
150
266
            return None
151
267
        if self.root is not None:
152
268
            return self.tree.abspath(self.tree.id2path(id))
153
269
        else:
154
 
            if self.tree.inventory[id].kind in ("directory", "root_directory"):
 
270
            kind = self.tree.inventory[id].kind
 
271
            if kind in ("directory", "root_directory"):
155
272
                return self.tempdir
156
273
            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))
 
274
                if kind == "file":
 
275
                    path = os.path.join(self.tempdir, "texts", id)
 
276
                    outfile = file(path, "wb")
 
277
                    outfile.write(self.tree.get_file(id).read())
 
278
                    assert(bzrlib.osutils.lexists(path))
 
279
                    if self.tree.is_executable(id):
 
280
                        os.chmod(path, 0755)
 
281
                else:
 
282
                    assert kind == "symlink"
 
283
                    path = os.path.join(self.tempdir, "symlinks", id)
 
284
                    target = self.tree.get_symlink_target(id)
 
285
                    os.symlink(target, path)
161
286
                self.cached[id] = path
162
287
            return self.cached[id]
163
288
 
164
289
 
 
290
def build_working_dir(to_dir):
 
291
    """Build a working directory in an empty directory.
 
292
 
 
293
    to_dir is a directory containing branch metadata but no working files,
 
294
    typically constructed by cloning an existing branch. 
 
295
 
 
296
    This is split out as a special idiomatic case of merge.  It could
 
297
    eventually be done by just building the tree directly calling into 
 
298
    lower-level code (e.g. constructing a changeset).
 
299
    """
 
300
    merge((to_dir, -1), (to_dir, 0), this_dir=to_dir,
 
301
          check_clean=False, ignore_zero=True)
 
302
 
165
303
 
166
304
def merge(other_revision, base_revision,
167
305
          check_clean=True, ignore_zero=False,
170
308
    """Merge changes into a tree.
171
309
 
172
310
    base_revision
173
 
        Base for three-way merge.
 
311
        tuple(path, revision) Base for three-way merge.
174
312
    other_revision
175
 
        Other revision for three-way merge.
 
313
        tuple(path, revision) Other revision for three-way merge.
176
314
    this_dir
177
315
        Directory to merge changes into; '.' by default.
178
316
    check_clean
179
317
        If true, this_dir must have no uncommitted changes before the
180
318
        merge begins.
 
319
    ignore_zero - If true, suppress the "zero conflicts" message when 
 
320
        there are no conflicts; should be set when doing something we expect
 
321
        to complete perfectly.
 
322
 
 
323
    All available ancestors of other_revision and base_revision are
 
324
    automatically pulled into the branch.
181
325
    """
182
326
    tempdir = tempfile.mkdtemp(prefix="bzr-")
183
327
    try:
184
328
        if this_dir is None:
185
329
            this_dir = '.'
186
 
        this_branch = find_branch(this_dir)
 
330
        this_branch = Branch.open_containing(this_dir)
 
331
        this_rev_id = this_branch.last_revision()
 
332
        if this_rev_id is None:
 
333
            raise BzrCommandError("This branch has no commits")
187
334
        if check_clean:
188
335
            changes = compare_trees(this_branch.working_tree(), 
189
336
                                    this_branch.basis_tree(), False)
190
337
            if changes.has_changed():
191
338
                raise BzrCommandError("Working tree has uncommitted changes.")
192
 
        other_branch, other_tree = get_tree(other_revision, tempdir, "other")
 
339
        other_branch, other_tree = get_tree(other_revision, tempdir, "other",
 
340
                                            this_branch)
 
341
        if other_revision[1] == -1:
 
342
            other_rev_id = other_branch.last_revision()
 
343
            if other_rev_id is None:
 
344
                raise NoCommits(other_branch)
 
345
            other_basis = other_rev_id
 
346
        elif other_revision[1] is not None:
 
347
            other_rev_id = other_branch.get_rev_id(other_revision[1])
 
348
            other_basis = other_rev_id
 
349
        else:
 
350
            other_rev_id = None
 
351
            other_basis = other_branch.last_revision()
 
352
            if other_basis is None:
 
353
                raise NoCommits(other_branch)
193
354
        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:
 
355
            try:
 
356
                base_rev_id = common_ancestor(this_rev_id, other_basis, 
 
357
                                              this_branch)
 
358
            except NoCommonAncestor:
201
359
                raise UnrelatedBranches()
202
 
            base_revision = ['.', base_revno]
203
 
        base_branch, base_tree = get_tree(base_revision, tempdir, "base")
 
360
            base_tree = get_revid_tree(this_branch, base_rev_id, tempdir, 
 
361
                                       "base", None)
 
362
            base_is_ancestor = True
 
363
        else:
 
364
            base_branch, base_tree = get_tree(base_revision, tempdir, "base")
 
365
            if base_revision[1] == -1:
 
366
                base_rev_id = base_branch.last_revision()
 
367
            elif base_revision[1] is None:
 
368
                base_rev_id = None
 
369
            else:
 
370
                base_rev_id = base_branch.get_rev_id(base_revision[1])
 
371
            fetch(from_branch=base_branch, to_branch=this_branch)
 
372
            base_is_ancestor = is_ancestor(this_rev_id, base_rev_id,
 
373
                                           this_branch)
204
374
        if file_list is None:
205
375
            interesting_ids = None
206
376
        else:
220
390
        merge_inner(this_branch, other_tree, base_tree, tempdir, 
221
391
                    ignore_zero=ignore_zero, backup_files=backup_files, 
222
392
                    merge_type=merge_type, interesting_ids=interesting_ids)
 
393
        if base_is_ancestor and other_rev_id is not None\
 
394
            and other_rev_id not in this_branch.revision_history():
 
395
            this_branch.add_pending_merge(other_rev_id)
223
396
    finally:
224
397
        shutil.rmtree(tempdir)
225
398
 
232
405
             source_file.interesting = source_file.id in interesting_ids
233
406
 
234
407
 
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.
 
408
def generate_cset_optimized(tree_a, tree_b, interesting_ids=None):
 
409
    """Generate a changeset.  If interesting_ids is supplied, only changes
 
410
    to those files will be shown.  Metadata changes are stripped.
259
411
    """ 
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)
 
412
    cset =  generate_changeset(tree_a, tree_b, interesting_ids)
265
413
    for entry in cset.entries.itervalues():
266
414
        entry.metadata_change = None
267
415
    return cset
271
419
                ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
272
420
                interesting_ids=None):
273
421
 
274
 
    def merge_factory(base_file, other_file):
275
 
        contents_change = merge_type(base_file, other_file)
 
422
    def merge_factory(file_id, base, other):
 
423
        contents_change = merge_type(file_id, base, other)
276
424
        if backup_files:
277
425
            contents_change = BackupBeforeChange(contents_change)
278
426
        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
427
 
284
428
    this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
285
429
 
286
430
    def get_inventory(tree):
287
 
        return tree.inventory
 
431
        return tree.tree.inventory
288
432
 
289
433
    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)
 
434
                             generate_cset_optimized, get_inventory,
 
435
                             MergeConflictHandler(this_tree, base_tree,
 
436
                             other_tree, ignore_zero=ignore_zero),
 
437
                             merge_factory=merge_factory, 
 
438
                             interesting_ids=interesting_ids)
294
439
 
295
440
    adjust_ids = []
296
441
    for id, path in inv_changes.iteritems():
298
443
            if path == '.':
299
444
                path = ''
300
445
            else:
301
 
                assert path.startswith('./')
 
446
                assert path.startswith('.' + os.sep), "path is %s" % path
302
447
            path = path[2:]
303
448
        adjust_ids.append((path, id))
304
 
    this_branch.set_inventory(regen_inventory(this_branch, this_tree.root, adjust_ids))
 
449
    if len(adjust_ids) > 0:
 
450
        this_branch.set_inventory(regen_inventory(this_branch, this_tree.root,
 
451
                                                  adjust_ids))
305
452
 
306
453
 
307
454
def regen_inventory(this_branch, root, new_entries):
308
455
    old_entries = this_branch.read_working_inventory()
309
456
    new_inventory = {}
310
457
    by_path = {}
 
458
    new_entries_map = {} 
 
459
    for path, file_id in new_entries:
 
460
        if path is None:
 
461
            continue
 
462
        new_entries_map[file_id] = path
 
463
 
 
464
    def id2path(file_id):
 
465
        path = new_entries_map.get(file_id)
 
466
        if path is not None:
 
467
            return path
 
468
        entry = old_entries[file_id]
 
469
        if entry.parent_id is None:
 
470
            return entry.name
 
471
        return os.path.join(id2path(entry.parent_id), entry.name)
 
472
        
311
473
    for file_id in old_entries:
312
474
        entry = old_entries[file_id]
313
 
        path = old_entries.id2path(file_id)
 
475
        path = id2path(file_id)
314
476
        new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
315
477
        by_path[path] = file_id
316
478