← 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-16 23:53:02 UTC
  • mto: This revision was merged to the branch mainline in revision 1459.
  • Revision ID: robertc@lifelesslap.robertcollins.net-20051016235302-818de607403e1c6e
test that the presence of a signature does not make a missing base file magically appear present

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