← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Robert Collins
  • Date: 2005-09-27 07:24:40 UTC
  • mfrom: (1185.1.41)
  • Revision ID: robertc@robertcollins.net-20050927072440-1bf4d99c3e1db5b3
pair programming worx... merge integration and weave

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commit.py
44
44
# TODO: Update hashcache before and after - or does the WorkingTree
45
45
# look after that?
46
46
 
 
47
# This code requires all merge parents to be present in the branch.
 
48
# We could relax this but for the sake of simplicity the constraint is
 
49
# here for now.  It's not totally clear to me how we'd know which file
 
50
# need new text versions if some parents are absent.  -- mbp 20050915
 
51
 
47
52
# TODO: Rather than mashing together the ancestry and storing it back,
48
53
# perhaps the weave should have single method which does it all in one
49
54
# go, avoiding a lot of redundant work.
56
61
# merges from, then it should still be reported as newly added
57
62
# relative to the basis revision.
58
63
 
59
 
# TODO: Do checks that the tree can be committed *before* running the 
60
 
# editor; this should include checks for a pointless commit and for 
61
 
# unknown or missing files.
62
 
 
63
 
# TODO: If commit fails, leave the message in a file somewhere.
64
 
 
65
64
 
66
65
import os
67
66
import re
72
71
from binascii import hexlify
73
72
from cStringIO import StringIO
74
73
 
75
 
from bzrlib.atomicfile import AtomicFile
76
 
from bzrlib.osutils import (local_time_offset,
77
 
                            rand_bytes, compact_date,
 
74
from bzrlib.osutils import (local_time_offset, username,
 
75
                            rand_bytes, compact_date, user_email,
78
76
                            kind_marker, is_inside_any, quotefn,
79
77
                            sha_string, sha_strings, sha_file, isdir, isfile,
80
78
                            split_lines)
81
 
import bzrlib.config
 
79
from bzrlib.branch import gen_file_id
82
80
from bzrlib.errors import (BzrError, PointlessCommit,
83
81
                           HistoryMissing,
84
 
                           ConflictsInTree,
85
 
                           StrictCommitFailed
86
82
                           )
87
 
import bzrlib.gpg as gpg
88
83
from bzrlib.revision import Revision
89
 
from bzrlib.testament import Testament
90
84
from bzrlib.trace import mutter, note, warning
91
85
from bzrlib.xml5 import serializer_v5
92
 
from bzrlib.inventory import Inventory, ROOT_ID
 
86
from bzrlib.inventory import Inventory
93
87
from bzrlib.weave import Weave
94
88
from bzrlib.weavefile import read_weave, write_weave_v5
95
 
from bzrlib.workingtree import WorkingTree
 
89
from bzrlib.atomicfile import AtomicFile
96
90
 
97
91
 
98
92
def commit(*args, **kwargs):
108
102
 
109
103
class NullCommitReporter(object):
110
104
    """I report on progress of a commit."""
111
 
 
112
 
    def snapshot_change(self, change, path):
113
 
        pass
114
 
 
115
 
    def completed(self, revno, rev_id):
116
 
        pass
117
 
 
118
 
    def deleted(self, file_id):
119
 
        pass
120
 
 
121
 
    def escaped(self, escape_count, message):
122
 
        pass
123
 
 
124
 
    def missing(self, path):
 
105
    def added(self, path):
 
106
        pass
 
107
 
 
108
    def removed(self, path):
 
109
        pass
 
110
 
 
111
    def renamed(self, old_path, new_path):
125
112
        pass
126
113
 
127
114
 
128
115
class ReportCommitToLog(NullCommitReporter):
129
 
 
130
 
    def snapshot_change(self, change, path):
131
 
        note("%s %s", change, path)
132
 
 
133
 
    def completed(self, revno, rev_id):
134
 
        note('committed r%d {%s}', revno, rev_id)
135
 
    
136
 
    def deleted(self, file_id):
137
 
        note('deleted %s', file_id)
138
 
 
139
 
    def escaped(self, escape_count, message):
140
 
        note("replaced %d control characters in message", escape_count)
141
 
 
142
 
    def missing(self, path):
143
 
        note('missing %s', path)
 
116
    def added(self, path):
 
117
        note('added %s', path)
 
118
 
 
119
    def removed(self, path):
 
120
        note('removed %s', path)
 
121
 
 
122
    def renamed(self, old_path, new_path):
 
123
        note('renamed %s => %s', old_path, new_path)
144
124
 
145
125
 
146
126
class Commit(object):
156
136
            working inventory.
157
137
    """
158
138
    def __init__(self,
159
 
                 reporter=None,
160
 
                 config=None):
 
139
                 reporter=None):
161
140
        if reporter is not None:
162
141
            self.reporter = reporter
163
142
        else:
164
143
            self.reporter = NullCommitReporter()
165
 
        if config is not None:
166
 
            self.config = config
167
 
        else:
168
 
            self.config = None
 
144
 
169
145
        
170
146
    def commit(self,
171
147
               branch, message,
175
151
               specific_files=None,
176
152
               rev_id=None,
177
153
               allow_pointless=True,
178
 
               strict=False,
179
 
               verbose=False,
180
 
               revprops=None):
 
154
               verbose=False):
181
155
        """Commit working copy as a new revision.
182
156
 
183
157
        timestamp -- if not None, seconds-since-epoch for a
193
167
 
194
168
        allow_pointless -- If true (default), commit even if nothing
195
169
            has changed and no merges are recorded.
196
 
 
197
 
        strict -- If true, don't allow a commit if the working tree
198
 
            contains unknown files.
199
 
 
200
 
        revprops -- Properties for new revision
201
170
        """
202
171
        mutter('preparing to commit')
203
172
 
206
175
        self.rev_id = rev_id
207
176
        self.specific_files = specific_files
208
177
        self.allow_pointless = allow_pointless
209
 
        self.revprops = {'branch-nick': branch.nick}
210
 
        if revprops:
211
 
            self.revprops.update(revprops)
212
 
        self.work_tree = WorkingTree(branch.base, branch)
213
 
 
214
 
        if strict:
215
 
            # raise an exception as soon as we find a single unknown.
216
 
            for unknown in self.work_tree.unknowns():
217
 
                raise StrictCommitFailed()
218
178
 
219
179
        if timestamp is None:
220
180
            self.timestamp = time.time()
221
181
        else:
222
182
            self.timestamp = long(timestamp)
223
183
            
224
 
        if self.config is None:
225
 
            self.config = bzrlib.config.BranchConfig(self.branch)
226
 
 
227
184
        if rev_id is None:
228
 
            self.rev_id = _gen_revision_id(self.config, self.timestamp)
 
185
            self.rev_id = _gen_revision_id(self.branch, self.timestamp)
229
186
        else:
230
187
            self.rev_id = rev_id
231
188
 
232
189
        if committer is None:
233
 
            self.committer = self.config.username()
 
190
            self.committer = username(self.branch)
234
191
        else:
235
192
            assert isinstance(committer, basestring), type(committer)
236
193
            self.committer = committer
240
197
        else:
241
198
            self.timezone = int(timezone)
242
199
 
243
 
        if isinstance(message, str):
244
 
            message = message.decode(bzrlib.user_encoding)
245
 
        assert isinstance(message, unicode), type(message)
 
200
        assert isinstance(message, basestring), type(message)
246
201
        self.message = message
247
202
        self._escape_commit_message()
248
203
 
249
204
        self.branch.lock_write()
250
205
        try:
 
206
            self.work_tree = self.branch.working_tree()
251
207
            self.work_inv = self.work_tree.inventory
252
208
            self.basis_tree = self.branch.basis_tree()
253
209
            self.basis_inv = self.basis_tree.inventory
258
214
            self._check_parents_present()
259
215
            
260
216
            self._remove_deleted()
261
 
            self._populate_new_inv()
262
 
            self._store_snapshot()
 
217
            self.new_inv = Inventory()
 
218
            self._store_entries()
263
219
            self._report_deletes()
 
220
            self._set_name_versions()
264
221
 
265
222
            if not (self.allow_pointless
266
223
                    or len(self.parents) > 1
267
224
                    or self.new_inv != self.basis_inv):
268
225
                raise PointlessCommit()
269
226
 
270
 
            if len(list(self.work_tree.iter_conflicts()))>0:
271
 
                raise ConflictsInTree
272
 
 
273
227
            self._record_inventory()
 
228
            self._record_ancestry()
274
229
            self._make_revision()
275
 
            self.work_tree.set_pending_merges([])
 
230
            note('committed r%d {%s}', (self.branch.revno() + 1),
 
231
                 self.rev_id)
276
232
            self.branch.append_revision(self.rev_id)
277
 
            self.reporter.completed(self.branch.revno()+1, self.rev_id)
278
 
            if self.config.post_commit() is not None:
279
 
                hooks = self.config.post_commit().split(' ')
280
 
                # this would be nicer with twisted.python.reflect.namedAny
281
 
                for hook in hooks:
282
 
                    result = eval(hook + '(branch, rev_id)',
283
 
                                  {'branch':self.branch,
284
 
                                   'bzrlib':bzrlib,
285
 
                                   'rev_id':self.rev_id})
 
233
            self.branch.set_pending_merges([])
286
234
        finally:
287
235
            self.branch.unlock()
288
236
 
 
237
 
 
238
 
289
239
    def _record_inventory(self):
290
240
        """Store the inventory for the new revision."""
291
241
        inv_text = serializer_v5.write_inventory_to_string(self.new_inv)
292
242
        self.inv_sha1 = sha_string(inv_text)
293
243
        s = self.branch.control_weaves
294
244
        s.add_text('inventory', self.rev_id,
295
 
                   split_lines(inv_text), self.present_parents,
296
 
                   self.branch.get_transaction())
 
245
                   split_lines(inv_text), self.parents)
297
246
 
298
247
    def _escape_commit_message(self):
299
248
        """Replace xml-incompatible control characters."""
301
250
        # represented in well-formed XML; escape characters that
302
251
        # aren't listed in the XML specification
303
252
        # (http://www.w3.org/TR/REC-xml/#NT-Char).
 
253
        if isinstance(self.message, unicode):
 
254
            char_pattern = u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]'
 
255
        else:
 
256
            # Use a regular 'str' as pattern to avoid having re.subn
 
257
            # return 'unicode' results.
 
258
            char_pattern = '[^x09\x0A\x0D\x20-\xFF]'
304
259
        self.message, escape_count = re.subn(
305
 
            u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
 
260
            char_pattern,
306
261
            lambda match: match.group(0).encode('unicode_escape'),
307
262
            self.message)
308
263
        if escape_count:
309
 
            self.reporter.escaped(escape_count, self.message)
 
264
            note("replaced %d control characters in message", escape_count)
 
265
 
 
266
    def _record_ancestry(self):
 
267
        """Append merged revision ancestry to the ancestry file.
 
268
 
 
269
        This should be the merged ancestry of all parents, plus the
 
270
        new revision id."""
 
271
        s = self.branch.control_weaves
 
272
        w = s.get_weave_or_empty('ancestry')
 
273
        lines = self._make_ancestry(w)
 
274
        w.add(self.rev_id, self.parents, lines)
 
275
        s.put_weave('ancestry', w)
 
276
 
 
277
 
 
278
    def _make_ancestry(self, ancestry_weave):
 
279
        """Return merged ancestry lines.
 
280
 
 
281
        The lines are revision-ids followed by newlines."""
 
282
        parent_ancestries = [ancestry_weave.get(p) for p in self.parents]
 
283
        new_lines = merge_ancestry_lines(self.rev_id, parent_ancestries)
 
284
        mutter('merged ancestry of {%s}:\n%s', self.rev_id, ''.join(new_lines))
 
285
        return new_lines
 
286
 
310
287
 
311
288
    def _gather_parents(self):
312
 
        """Record the parents of a merge for merge detection."""
313
 
        pending_merges = self.work_tree.pending_merges()
 
289
        pending_merges = self.branch.pending_merges()
314
290
        self.parents = []
315
 
        self.parent_invs = []
316
 
        self.present_parents = []
 
291
        self.parent_trees = []
317
292
        precursor_id = self.branch.last_revision()
318
293
        if precursor_id:
319
294
            self.parents.append(precursor_id)
 
295
            self.parent_trees.append(self.basis_tree)
320
296
        self.parents += pending_merges
321
 
        for revision in self.parents:
322
 
            if self.branch.has_revision(revision):
323
 
                self.parent_invs.append(self.branch.get_inventory(revision))
324
 
                self.present_parents.append(revision)
 
297
        self.parent_trees.extend(map(self.branch.revision_tree, pending_merges))
 
298
 
325
299
 
326
300
    def _check_parents_present(self):
327
301
        for parent_id in self.parents:
328
302
            mutter('commit parent revision {%s}', parent_id)
329
303
            if not self.branch.has_revision(parent_id):
330
 
                if parent_id == self.branch.last_revision():
331
 
                    warning("parent is missing %r", parent_id)
332
 
                    raise HistoryMissing(self.branch, 'revision', parent_id)
333
 
                else:
334
 
                    mutter("commit will ghost revision %r", parent_id)
 
304
                warning("can't commit a merge from an absent parent")
 
305
                raise HistoryMissing(self.branch, 'revision', parent_id)
 
306
 
335
307
            
336
308
    def _make_revision(self):
337
309
        """Record a new revision object for this commit."""
340
312
                            committer=self.committer,
341
313
                            message=self.message,
342
314
                            inventory_sha1=self.inv_sha1,
343
 
                            revision_id=self.rev_id,
344
 
                            properties=self.revprops)
 
315
                            revision_id=self.rev_id)
345
316
        self.rev.parent_ids = self.parents
346
317
        rev_tmp = StringIO()
347
318
        serializer_v5.write_revision(self.rev, rev_tmp)
348
319
        rev_tmp.seek(0)
349
 
        if self.config.signature_needed():
350
 
            plaintext = Testament(self.rev, self.new_inv).as_short_text()
351
 
            self.branch.store_revision_signature(gpg.GPGStrategy(self.config),
352
 
                                                 plaintext, self.rev_id)
353
 
        self.branch.revision_store.add(rev_tmp, self.rev_id)
 
320
        self.branch.revision_store.add(rev_tmp, self.rev_id, compressed=False)
354
321
        mutter('new revision_id is {%s}', self.rev_id)
355
322
 
 
323
 
356
324
    def _remove_deleted(self):
357
325
        """Remove deleted files from the working inventories.
358
326
 
370
338
            if specific and not is_inside_any(specific, path):
371
339
                continue
372
340
            if not self.work_tree.has_filename(path):
373
 
                self.reporter.missing(path)
374
 
                deleted_ids.append((path, ie.file_id))
 
341
                note('missing %s', path)
 
342
                deleted_ids.append(ie.file_id)
375
343
        if deleted_ids:
376
 
            deleted_ids.sort(reverse=True)
377
 
            for path, file_id in deleted_ids:
 
344
            for file_id in deleted_ids:
378
345
                del self.work_inv[file_id]
379
 
            self.work_tree._write_inventory(self.work_inv)
380
 
 
381
 
    def _store_snapshot(self):
382
 
        """Pass over inventory and record a snapshot.
383
 
 
384
 
        Entries get a new revision when they are modified in 
385
 
        any way, which includes a merge with a new set of
386
 
        parents that have the same entry. 
387
 
        """
 
346
            self.branch._write_inventory(self.work_inv)
 
347
 
 
348
 
 
349
    def _find_file_parents(self, file_id):
 
350
        """Return the text versions and hashes for all file parents.
 
351
 
 
352
        Returned as a map from text version to inventory entry.
 
353
 
 
354
        This is a set containing the file versions in all parents
 
355
        revisions containing the file.  If the file is new, the set
 
356
        will be empty."""
 
357
        r = {}
 
358
        for tree in self.parent_trees:
 
359
            if file_id in tree.inventory:
 
360
                ie = tree.inventory[file_id]
 
361
                assert ie.kind == 'file'
 
362
                assert ie.file_id == file_id
 
363
                if ie.text_version in r:
 
364
                    assert r[ie.text_version] == ie
 
365
                else:
 
366
                    r[ie.text_version] = ie
 
367
        return r
 
368
 
 
369
 
 
370
    def _set_name_versions(self):
 
371
        """Pass over inventory and mark new entry version as needed.
 
372
 
 
373
        Files get a new name version when they are new, have a
 
374
        different parent, or a different name from in the
 
375
        basis inventory, or if the file is in a different place
 
376
        to any of the parents."""
388
377
        # XXX: Need to think more here about when the user has
389
378
        # made a specific decision on a particular value -- c.f.
390
379
        # mark-merge.  
391
380
        for path, ie in self.new_inv.iter_entries():
392
 
            previous_entries = ie.find_previous_heads(
393
 
                self.parent_invs, 
394
 
                self.weave_store.get_weave_or_empty(ie.file_id,
395
 
                    self.branch.get_transaction()))
396
 
            if ie.revision is None:
397
 
                change = ie.snapshot(self.rev_id, path, previous_entries,
398
 
                                     self.work_tree, self.weave_store,
399
 
                                     self.branch.get_transaction())
 
381
            old_version = None
 
382
            file_id = ie.file_id
 
383
            for parent_tree in self.parent_trees:
 
384
                parent_inv = parent_tree.inventory
 
385
                if file_id not in parent_inv:
 
386
                    continue
 
387
                parent_ie = parent_inv[file_id]
 
388
                if parent_ie.parent_id != ie.parent_id:
 
389
                    old_version = None
 
390
                    break
 
391
                elif parent_ie.name != ie.name:
 
392
                    old_version = None
 
393
                    break
 
394
                elif old_version is None:
 
395
                    old_version = parent_ie.name_version
 
396
                elif old_version != parent_ie.name_version:
 
397
                    old_version = None
 
398
                    break
 
399
                else:
 
400
                    pass                # so far so good
 
401
            if old_version is None:
 
402
                mutter('new name_version for {%s}', file_id)
 
403
                ie.name_version = self.rev_id
400
404
            else:
401
 
                change = "unchanged"
402
 
            self.reporter.snapshot_change(change, path)
403
 
 
404
 
    def _populate_new_inv(self):
405
 
        """Build revision inventory.
406
 
 
407
 
        This creates a new empty inventory. Depending on
408
 
        which files are selected for commit, and what is present in the
409
 
        current tree, the new inventory is populated. inventory entries 
410
 
        which are candidates for modification have their revision set to
411
 
        None; inventory entries that are carried over untouched have their
412
 
        revision set to their prior value.
 
405
                mutter('name_version for {%s} inherited as {%s}',
 
406
                       file_id, old_version)
 
407
                ie.name_version = old_version
 
408
 
 
409
 
 
410
    def _store_entries(self):
 
411
        """Build revision inventory and store modified files.
 
412
 
 
413
        This is called with new_inv a new empty inventory.  Depending on
 
414
        which files are selected for commit, and which ones have
 
415
        been modified or merged, new inventory entries are built
 
416
        based on the working and parent inventories.
 
417
 
 
418
        As a side-effect this stores new text versions for committed
 
419
        files with text changes or merges.
 
420
 
 
421
        Each entry can have one of several things happen:
 
422
 
 
423
        carry_file -- carried from the previous version (if not
 
424
            selected for commit)
 
425
 
 
426
        commit_nonfile -- no text to worry about
 
427
 
 
428
        commit_old_text -- same text, may have moved
 
429
 
 
430
        commit_file -- new text version
413
431
        """
414
 
        mutter("Selecting files for commit with filter %s", self.specific_files)
415
 
        self.new_inv = Inventory()
416
432
        for path, new_ie in self.work_inv.iter_entries():
417
433
            file_id = new_ie.file_id
418
434
            mutter('check %s {%s}', path, new_ie.file_id)
419
435
            if self.specific_files:
420
436
                if not is_inside_any(self.specific_files, path):
421
437
                    mutter('%s not selected for commit', path)
422
 
                    self._carry_entry(file_id)
423
 
                    continue
424
 
                else:
425
 
                    # this is selected, ensure its parents are too.
426
 
                    parent_id = new_ie.parent_id
427
 
                    while parent_id != ROOT_ID:
428
 
                        if not self.new_inv.has_id(parent_id):
429
 
                            ie = self._select_entry(self.work_inv[parent_id])
430
 
                            mutter('%s selected for commit because of %s',
431
 
                                   self.new_inv.id2path(parent_id), path)
432
 
 
433
 
                        ie = self.new_inv[parent_id]
434
 
                        if ie.revision is not None:
435
 
                            ie.revision = None
436
 
                            mutter('%s selected for commit because of %s',
437
 
                                   self.new_inv.id2path(parent_id), path)
438
 
                        parent_id = ie.parent_id
439
 
            mutter('%s selected for commit', path)
440
 
            self._select_entry(new_ie)
441
 
 
442
 
    def _select_entry(self, new_ie):
443
 
        """Make new_ie be considered for committing."""
444
 
        ie = new_ie.copy()
445
 
        ie.revision = None
446
 
        self.new_inv.add(ie)
447
 
        return ie
448
 
 
449
 
    def _carry_entry(self, file_id):
 
438
                    self._carry_file(file_id)
 
439
                    continue
 
440
            if new_ie.kind != 'file':
 
441
                self._commit_nonfile(file_id)
 
442
                continue
 
443
            
 
444
            file_parents = self._find_file_parents(file_id)
 
445
            mutter('parents of %s are %r', path, file_parents)
 
446
            if len(file_parents) == 1:
 
447
                parent_ie = file_parents.values()[0]
 
448
                wc_sha1 = self.work_tree.get_file_sha1(file_id)
 
449
                if parent_ie.text_sha1 == wc_sha1:
 
450
                    # text not changed or merged
 
451
                    self._commit_old_text(file_id, parent_ie)
 
452
                    continue
 
453
            # file is either new, or a file merge; need to record
 
454
            # a new version
 
455
            if len(file_parents) > 1:
 
456
                note('merged %s', path)
 
457
            elif len(file_parents) == 0:
 
458
                note('added %s', path)
 
459
            else:
 
460
                note('modified %s', path)
 
461
            self._commit_file(new_ie, file_id, file_parents)
 
462
 
 
463
 
 
464
    def _commit_nonfile(self, file_id):
 
465
        self.new_inv.add(self.work_inv[file_id].copy())
 
466
 
 
467
 
 
468
    def _carry_file(self, file_id):
450
469
        """Carry the file unchanged from the basis revision."""
451
470
        if self.basis_inv.has_id(file_id):
452
471
            self.new_inv.add(self.basis_inv[file_id].copy())
453
472
 
 
473
 
 
474
    def _commit_old_text(self, file_id, parent_ie):
 
475
        """Keep the same text as last time, but possibly a different name."""
 
476
        ie = self.work_inv[file_id].copy()
 
477
        ie.text_version = parent_ie.text_version
 
478
        ie.text_size = parent_ie.text_size
 
479
        ie.text_sha1 = parent_ie.text_sha1
 
480
        self.new_inv.add(ie)
 
481
 
 
482
 
454
483
    def _report_deletes(self):
455
484
        for file_id in self.basis_inv:
456
485
            if file_id not in self.new_inv:
457
 
                self.reporter.deleted(self.basis_inv.id2path(file_id))
458
 
 
459
 
def _gen_revision_id(config, when):
 
486
                note('deleted %s', self.basis_inv.id2path(file_id))
 
487
 
 
488
 
 
489
    def _commit_file(self, new_ie, file_id, file_parents):                    
 
490
        mutter('store new text for {%s} in revision {%s}',
 
491
               file_id, self.rev_id)
 
492
        new_lines = self.work_tree.get_file(file_id).readlines()
 
493
        self._add_text_to_weave(file_id, new_lines, file_parents)
 
494
        new_ie.text_version = self.rev_id
 
495
        new_ie.text_sha1 = sha_strings(new_lines)
 
496
        new_ie.text_size = sum(map(len, new_lines))
 
497
        self.new_inv.add(new_ie)
 
498
 
 
499
 
 
500
    def _add_text_to_weave(self, file_id, new_lines, parents):
 
501
        self.weave_store.add_text(file_id, self.rev_id, new_lines, parents)
 
502
 
 
503
 
 
504
def _gen_revision_id(branch, when):
460
505
    """Return new revision-id."""
461
 
    s = '%s-%s-' % (config.user_email(), compact_date(when))
 
506
    s = '%s-%s-' % (user_email(branch), compact_date(when))
462
507
    s += hexlify(rand_bytes(8))
463
508
    return s
 
509
 
 
510
 
 
511
 
 
512
    
 
513
def merge_ancestry_lines(rev_id, ancestries):
 
514
    """Return merged ancestry lines.
 
515
 
 
516
    rev_id -- id of the new revision
 
517
    
 
518
    ancestries -- a sequence of ancestries for parent revisions,
 
519
        as newline-terminated line lists.
 
520
    """
 
521
    if len(ancestries) == 0:
 
522
        return [rev_id + '\n']
 
523
    seen = set(ancestries[0])
 
524
    ancs = ancestries[0][:]    
 
525
    for parent_ancestry in ancestries[1:]:
 
526
        for line in parent_ancestry:
 
527
            assert line[-1] == '\n'
 
528
            if line not in seen:
 
529
                ancs.append(line)
 
530
                seen.add(line)
 
531
    r = rev_id + '\n'
 
532
    assert r not in seen
 
533
    ancs.append(r)
 
534
    return ancs