← 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-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:
bzrlib/merge.py
124
124
 
125
125
    def new_contents_conflict(self, filename, other_contents):
126
126
        """Conflicting contents for newly added file."""
127
 
        self.copy(other_contents, filename + ".OTHER")
 
127
        other.contents.apply(filename + ".OTHER")
128
128
        self.conflict("Conflict in newly added file %s" % filename)
129
129
    
130
130
 
153
153
 
154
154
    def abs_this_path(self, file_id):
155
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)
 
156
        return self.this_tree.id2abspath(file_id)
158
157
 
159
158
    def add_missing_parents(self, file_id, tree):
160
159
        """If some of the parents for file_id are missing, add them."""
161
 
        entry = tree.tree.inventory[file_id]
 
160
        entry = tree.inventory[file_id]
162
161
        if entry.parent_id not in self.this_tree:
163
162
            return self.create_all_missing(entry.parent_id, tree)
164
163
        else:
166
165
 
167
166
    def create_all_missing(self, file_id, tree):
168
167
        """Add contents for a file_id and all its parents to a tree."""
169
 
        entry = tree.tree.inventory[file_id]
 
168
        entry = tree.inventory[file_id]
170
169
        if entry.parent_id is not None and entry.parent_id not in self.this_tree:
171
170
            abspath = self.create_all_missing(entry.parent_id, tree)
172
171
        else:
178
177
 
179
178
    def create(self, file_id, path, tree, reverse=False):
180
179
        """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)
 
180
        from changeset import get_contents
 
181
        get_contents(tree, file_id)(path, self, reverse)
183
182
 
184
183
    def missing_for_merge(self, file_id, other_path):
185
184
        """The file_id doesn't exist in THIS, but does in OTHER and BASE"""
190
189
        self.create(file_id, stem+".OTHER", self.other_tree)
191
190
        self.create(file_id, stem+".BASE", self.base_tree)
192
191
 
 
192
    def threeway_contents_conflict(filename, this_contents, base_contents,
 
193
                                   other_contents):
 
194
        self.conflict("Three-way conflict merging %s" % filename)
 
195
 
193
196
    def finalize(self):
194
197
        if not self.ignore_zero:
195
198
            note("%d conflicts encountered.\n" % self.conflicts)
196
199
            
197
 
def get_tree(treespec, temp_root, label, local_branch=None):
 
200
def get_tree(treespec, local_branch=None):
198
201
    location, revno = treespec
199
202
    branch = Branch.open_containing(location)
200
203
    if revno is None:
203
206
        revision = branch.last_revision()
204
207
    else:
205
208
        revision = branch.get_rev_id(revno)
206
 
    return branch, get_revid_tree(branch, revision, temp_root, label,
207
 
                                  local_branch)
 
209
    return branch, get_revid_tree(branch, revision, local_branch)
208
210
 
209
 
def get_revid_tree(branch, revision, temp_root, label, local_branch):
 
211
def get_revid_tree(branch, revision, local_branch):
210
212
    if revision is None:
211
213
        base_tree = branch.working_tree()
212
214
    else:
215
217
            base_tree = local_branch.revision_tree(revision)
216
218
        else:
217
219
            base_tree = branch.revision_tree(revision)
218
 
    temp_path = os.path.join(temp_root, label)
219
 
    os.mkdir(temp_path)
220
 
    return MergeTree(base_tree, temp_path)
 
220
    return base_tree
221
221
 
222
222
 
223
223
def file_exists(tree, file_id):
224
224
    return tree.has_filename(tree.id2path(file_id))
225
225
    
226
226
 
227
 
class MergeTree(object):
228
 
    def __init__(self, tree, tempdir):
229
 
        object.__init__(self)
230
 
        if hasattr(tree, "basedir"):
231
 
            self.root = tree.basedir
232
 
        else:
233
 
            self.root = None
234
 
        self.tree = tree
235
 
        self.tempdir = tempdir
236
 
        os.mkdir(os.path.join(self.tempdir, "texts"))
237
 
        os.mkdir(os.path.join(self.tempdir, "symlinks"))
238
 
        self.cached = {}
239
 
 
240
 
    def __iter__(self):
241
 
        return self.tree.__iter__()
242
 
 
243
 
    def __contains__(self, file_id):
244
 
        return file_id in self.tree
245
 
 
246
 
    def get_file(self, file_id):
247
 
        return self.tree.get_file(file_id)
248
 
 
249
 
    def get_file_sha1(self, id):
250
 
        return self.tree.get_file_sha1(id)
251
 
 
252
 
    def is_executable(self, id):
253
 
        return self.tree.is_executable(id)
254
 
 
255
 
    def id2path(self, file_id):
256
 
        return self.tree.id2path(file_id)
257
 
 
258
 
    def has_id(self, file_id):
259
 
        return self.tree.has_id(file_id)
260
 
 
261
 
    def has_or_had_id(self, file_id):
262
 
        if file_id == self.tree.inventory.root.file_id:
263
 
            return True
264
 
        return self.tree.inventory.has_id(file_id)
265
 
 
266
 
    def has_or_had_id(self, file_id):
267
 
        if file_id == self.tree.inventory.root.file_id:
268
 
            return True
269
 
        return self.tree.inventory.has_id(file_id)
270
 
 
271
 
    def readonly_path(self, id):
272
 
        if id not in self.tree:
273
 
            return None
274
 
        if self.root is not None:
275
 
            return self.tree.abspath(self.tree.id2path(id))
276
 
        else:
277
 
            kind = self.tree.inventory[id].kind
278
 
            if kind in ("directory", "root_directory"):
279
 
                return self.tempdir
280
 
            if not self.cached.has_key(id):
281
 
                if kind == "file":
282
 
                    path = os.path.join(self.tempdir, "texts", id)
283
 
                    outfile = file(path, "wb")
284
 
                    outfile.write(self.tree.get_file(id).read())
285
 
                    assert(bzrlib.osutils.lexists(path))
286
 
                    if self.tree.is_executable(id):
287
 
                        os.chmod(path, 0755)
288
 
                else:
289
 
                    assert kind == "symlink"
290
 
                    path = os.path.join(self.tempdir, "symlinks", id)
291
 
                    target = self.tree.get_symlink_target(id)
292
 
                    os.symlink(target, path)
293
 
                self.cached[id] = path
294
 
            return self.cached[id]
295
 
 
296
 
 
297
227
def build_working_dir(to_dir):
298
228
    """Build a working directory in an empty directory.
299
229
 
343
273
                                    this_branch.basis_tree(), False)
344
274
            if changes.has_changed():
345
275
                raise BzrCommandError("Working tree has uncommitted changes.")
346
 
        other_branch, other_tree = get_tree(other_revision, tempdir, "other",
347
 
                                            this_branch)
 
276
        other_branch, other_tree = get_tree(other_revision, this_branch)
348
277
        if other_revision[1] == -1:
349
278
            other_rev_id = other_branch.last_revision()
350
279
            if other_rev_id is None:
364
293
                                              this_branch)
365
294
            except NoCommonAncestor:
366
295
                raise UnrelatedBranches()
367
 
            base_tree = get_revid_tree(this_branch, base_rev_id, tempdir, 
368
 
                                       "base", None)
 
296
            base_tree = get_revid_tree(this_branch, base_rev_id, None)
369
297
            base_is_ancestor = True
370
298
        else:
371
 
            base_branch, base_tree = get_tree(base_revision, tempdir, "base")
 
299
            base_branch, base_tree = get_tree(base_revision)
372
300
            if base_revision[1] == -1:
373
301
                base_rev_id = base_branch.last_revision()
374
302
            elif base_revision[1] is None:
384
312
            interesting_ids = set()
385
313
            this_tree = this_branch.working_tree()
386
314
            for fname in file_list:
387
 
                path = this_branch.relpath(fname)
 
315
                path = this_tree.relpath(fname)
388
316
                found_id = False
389
 
                for tree in (this_tree, base_tree.tree, other_tree.tree):
 
317
                for tree in (this_tree, base_tree, other_tree):
390
318
                    file_id = tree.inventory.path2id(path)
391
319
                    if file_id is not None:
392
320
                        interesting_ids.add(file_id)
422
350
            contents_change = BackupBeforeChange(contents_change)
423
351
        return contents_change
424
352
 
425
 
    this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
 
353
    this_tree = get_tree((this_branch.base, None))[1]
426
354
 
427
355
    def get_inventory(tree):
428
 
        return tree.tree.inventory
 
356
        return tree.inventory
429
357
 
430
358
    inv_changes = merge_flex(this_tree, base_tree, other_tree,
431
359
                             generate_changeset, get_inventory,
444
372
            path = path[2:]
445
373
        adjust_ids.append((path, id))
446
374
    if len(adjust_ids) > 0:
447
 
        this_branch.set_inventory(regen_inventory(this_branch, this_tree.root,
 
375
        this_branch.set_inventory(regen_inventory(this_branch, 
 
376
                                                  this_tree.basedir,
448
377
                                                  adjust_ids))
449
378
 
450
379