← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

merge with bzr.dev revno.1860

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commit.py
1
 
# Copyright (C) 2005 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
56
56
# merges from, then it should still be reported as newly added
57
57
# relative to the basis revision.
58
58
 
 
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
 
59
65
 
60
66
import os
61
67
import re
62
68
import sys
63
69
import time
64
 
import pdb
 
70
import warnings
65
71
 
66
 
from binascii import hexlify
67
72
from cStringIO import StringIO
68
73
 
69
 
from bzrlib.osutils import (local_time_offset, username,
70
 
                            rand_bytes, compact_date, user_email,
71
 
                            kind_marker, is_inside_any, quotefn,
72
 
                            sha_string, sha_strings, sha_file, isdir, isfile,
73
 
                            split_lines)
74
 
from bzrlib.branch import gen_file_id
 
74
from bzrlib.atomicfile import AtomicFile
 
75
import bzrlib.config
 
76
import bzrlib.errors as errors
75
77
from bzrlib.errors import (BzrError, PointlessCommit,
76
 
                           HistoryMissing,
 
78
                           ConflictsInTree,
 
79
                           StrictCommitFailed
77
80
                           )
78
 
from bzrlib.revision import Revision
 
81
from bzrlib.osutils import (kind_marker, isdir,isfile, is_inside_any, 
 
82
                            is_inside_or_parent_of_any,
 
83
                            quotefn, sha_file, split_lines)
 
84
from bzrlib.testament import Testament
79
85
from bzrlib.trace import mutter, note, warning
80
86
from bzrlib.xml5 import serializer_v5
81
 
from bzrlib.inventory import Inventory
82
 
from bzrlib.weave import Weave
83
 
from bzrlib.weavefile import read_weave, write_weave_v5
84
 
from bzrlib.atomicfile import AtomicFile
85
 
 
86
 
 
 
87
from bzrlib.inventory import Inventory, ROOT_ID, InventoryEntry
 
88
from bzrlib.symbol_versioning import (deprecated_passed,
 
89
        deprecated_function,
 
90
        zero_seven,
 
91
        DEPRECATED_PARAMETER)
 
92
from bzrlib.workingtree import WorkingTree
 
93
 
 
94
 
 
95
@deprecated_function(zero_seven)
87
96
def commit(*args, **kwargs):
88
97
    """Commit a new revision to a branch.
89
98
 
91
100
 
92
101
    New code should use the Commit class instead.
93
102
    """
94
 
    ## XXX: Remove this in favor of Branch.commit?
 
103
    ## XXX: Remove this in favor of WorkingTree.commit?
95
104
    Commit().commit(*args, **kwargs)
96
105
 
97
106
 
98
107
class NullCommitReporter(object):
99
108
    """I report on progress of a commit."""
100
 
    def added(self, path):
101
 
        pass
102
 
 
103
 
    def removed(self, path):
104
 
        pass
105
 
 
106
 
    def renamed(self, old_path, new_path):
 
109
 
 
110
    def snapshot_change(self, change, path):
 
111
        pass
 
112
 
 
113
    def completed(self, revno, rev_id):
 
114
        pass
 
115
 
 
116
    def deleted(self, file_id):
 
117
        pass
 
118
 
 
119
    def escaped(self, escape_count, message):
 
120
        pass
 
121
 
 
122
    def missing(self, path):
 
123
        pass
 
124
 
 
125
    def renamed(self, change, old_path, new_path):
107
126
        pass
108
127
 
109
128
 
110
129
class ReportCommitToLog(NullCommitReporter):
111
 
    def added(self, path):
112
 
        note('added %s', path)
113
 
 
114
 
    def removed(self, path):
115
 
        note('removed %s', path)
116
 
 
117
 
    def renamed(self, old_path, new_path):
118
 
        note('renamed %s => %s', old_path, new_path)
 
130
 
 
131
    # this may be more useful if 'note' was replaced by an overridable
 
132
    # method on self, which would allow more trivial subclassing.
 
133
    # alternative, a callable could be passed in, allowing really trivial
 
134
    # reuse for some uis. RBC 20060511
 
135
 
 
136
    def snapshot_change(self, change, path):
 
137
        if change == 'unchanged':
 
138
            return
 
139
        note("%s %s", change, path)
 
140
 
 
141
    def completed(self, revno, rev_id):
 
142
        note('Committed revision %d.', revno)
 
143
    
 
144
    def deleted(self, file_id):
 
145
        note('deleted %s', file_id)
 
146
 
 
147
    def escaped(self, escape_count, message):
 
148
        note("replaced %d control characters in message", escape_count)
 
149
 
 
150
    def missing(self, path):
 
151
        note('missing %s', path)
 
152
 
 
153
    def renamed(self, change, old_path, new_path):
 
154
        note('%s %s => %s', change, old_path, new_path)
119
155
 
120
156
 
121
157
class Commit(object):
131
167
            working inventory.
132
168
    """
133
169
    def __init__(self,
134
 
                 reporter=None):
 
170
                 reporter=None,
 
171
                 config=None):
135
172
        if reporter is not None:
136
173
            self.reporter = reporter
137
174
        else:
138
175
            self.reporter = NullCommitReporter()
139
 
 
 
176
        if config is not None:
 
177
            self.config = config
 
178
        else:
 
179
            self.config = None
140
180
        
141
181
    def commit(self,
142
 
               branch, message,
 
182
               branch=DEPRECATED_PARAMETER, message=None,
143
183
               timestamp=None,
144
184
               timezone=None,
145
185
               committer=None,
146
186
               specific_files=None,
147
187
               rev_id=None,
148
188
               allow_pointless=True,
149
 
               verbose=False):
 
189
               strict=False,
 
190
               verbose=False,
 
191
               revprops=None,
 
192
               working_tree=None,
 
193
               local=False,
 
194
               reporter=None,
 
195
               config=None):
150
196
        """Commit working copy as a new revision.
151
197
 
 
198
        branch -- the deprecated branch to commit to. New callers should pass in 
 
199
                  working_tree instead
 
200
 
 
201
        message -- the commit message, a mandatory parameter
 
202
 
152
203
        timestamp -- if not None, seconds-since-epoch for a
153
204
             postdated/predated commit.
154
205
 
162
213
 
163
214
        allow_pointless -- If true (default), commit even if nothing
164
215
            has changed and no merges are recorded.
 
216
 
 
217
        strict -- If true, don't allow a commit if the working tree
 
218
            contains unknown files.
 
219
 
 
220
        revprops -- Properties for new revision
 
221
        :param local: Perform a local only commit.
165
222
        """
166
223
        mutter('preparing to commit')
167
224
 
168
 
        self.branch = branch
169
 
        self.weave_store = branch.weave_store
170
 
        self.rev_id = rev_id
 
225
        if deprecated_passed(branch):
 
226
            warnings.warn("Commit.commit (branch, ...): The branch parameter is "
 
227
                 "deprecated as of bzr 0.8. Please use working_tree= instead.",
 
228
                 DeprecationWarning, stacklevel=2)
 
229
            self.branch = branch
 
230
            self.work_tree = self.branch.bzrdir.open_workingtree()
 
231
        elif working_tree is None:
 
232
            raise BzrError("One of branch and working_tree must be passed into commit().")
 
233
        else:
 
234
            self.work_tree = working_tree
 
235
            self.branch = self.work_tree.branch
 
236
        if message is None:
 
237
            raise BzrError("The message keyword parameter is required for commit().")
 
238
 
 
239
        self.bound_branch = None
 
240
        self.local = local
 
241
        self.master_branch = None
 
242
        self.master_locked = False
 
243
        self.rev_id = None
171
244
        self.specific_files = specific_files
172
245
        self.allow_pointless = allow_pointless
173
246
 
174
 
        if timestamp is None:
175
 
            self.timestamp = time.time()
176
 
        else:
177
 
            self.timestamp = long(timestamp)
178
 
            
179
 
        if rev_id is None:
180
 
            self.rev_id = _gen_revision_id(self.branch, self.timestamp)
181
 
        else:
182
 
            self.rev_id = rev_id
183
 
 
184
 
        if committer is None:
185
 
            self.committer = username(self.branch)
186
 
        else:
187
 
            assert isinstance(committer, basestring), type(committer)
188
 
            self.committer = committer
189
 
 
190
 
        if timezone is None:
191
 
            self.timezone = local_time_offset()
192
 
        else:
193
 
            self.timezone = int(timezone)
194
 
 
195
 
        assert isinstance(message, basestring), type(message)
196
 
        self.message = message
197
 
        self._escape_commit_message()
198
 
 
199
 
        self.branch.lock_write()
 
247
        if reporter is None and self.reporter is None:
 
248
            self.reporter = NullCommitReporter()
 
249
        elif reporter is not None:
 
250
            self.reporter = reporter
 
251
 
 
252
        self.work_tree.lock_write()
 
253
        self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
200
254
        try:
201
 
            self.work_tree = self.branch.working_tree()
 
255
            # Cannot commit with conflicts present.
 
256
            if len(self.work_tree.conflicts())>0:
 
257
                raise ConflictsInTree
 
258
 
 
259
            # setup the bound branch variables as needed.
 
260
            self._check_bound_branch()
 
261
 
 
262
            # check for out of date working trees
 
263
            # if we are bound, then self.branch is the master branch and this
 
264
            # test is thus all we need.
 
265
            if self.work_tree.last_revision() != self.master_branch.last_revision():
 
266
                raise errors.OutOfDateTree(self.work_tree)
 
267
    
 
268
            if strict:
 
269
                # raise an exception as soon as we find a single unknown.
 
270
                for unknown in self.work_tree.unknowns():
 
271
                    raise StrictCommitFailed()
 
272
                   
 
273
            if self.config is None:
 
274
                self.config = self.branch.get_config()
 
275
      
 
276
            if isinstance(message, str):
 
277
                message = message.decode(bzrlib.user_encoding)
 
278
            assert isinstance(message, unicode), type(message)
 
279
            self.message = message
 
280
            self._escape_commit_message()
 
281
 
202
282
            self.work_inv = self.work_tree.inventory
203
 
            self.basis_tree = self.branch.basis_tree()
 
283
            self.basis_tree = self.work_tree.basis_tree()
204
284
            self.basis_inv = self.basis_tree.inventory
 
285
            # one to finish, one for rev and inventory, and one for each
 
286
            # inventory entry, and the same for the new inventory.
 
287
            # note that this estimate is too long when we do a partial tree
 
288
            # commit which excludes some new files from being considered.
 
289
            # The estimate is corrected when we populate the new inv.
 
290
            self.pb_total = len(self.work_inv) + 5
 
291
            self.pb_count = 0
205
292
 
206
293
            self._gather_parents()
207
294
            if len(self.parents) > 1 and self.specific_files:
208
 
                raise NotImplementedError('selected-file commit of merges is not supported yet')
 
295
                raise NotImplementedError('selected-file commit of merges is not supported yet: files %r',
 
296
                        self.specific_files)
209
297
            self._check_parents_present()
 
298
            self.builder = self.branch.get_commit_builder(self.parents, 
 
299
                self.config, timestamp, timezone, committer, revprops, rev_id)
210
300
            
211
301
            self._remove_deleted()
212
302
            self._populate_new_inv()
213
 
            self._store_snapshot()
214
303
            self._report_deletes()
215
304
 
216
305
            if not (self.allow_pointless
217
306
                    or len(self.parents) > 1
218
 
                    or self.new_inv != self.basis_inv):
 
307
                    or self.builder.new_inventory != self.basis_inv):
219
308
                raise PointlessCommit()
220
309
 
221
 
            self._record_inventory()
222
 
            self._record_ancestry()
223
 
            self._make_revision()
224
 
            note('committed r%d {%s}', (self.branch.revno() + 1),
225
 
                 self.rev_id)
 
310
            self._emit_progress_update()
 
311
            # TODO: Now the new inventory is known, check for conflicts and prompt the 
 
312
            # user for a commit message.
 
313
            self.builder.finish_inventory()
 
314
            self._emit_progress_update()
 
315
            self.rev_id = self.builder.commit(self.message)
 
316
            self._emit_progress_update()
 
317
            # revision data is in the local branch now.
 
318
            
 
319
            # upload revision data to the master.
 
320
            # this will propagate merged revisions too if needed.
 
321
            if self.bound_branch:
 
322
                self.master_branch.repository.fetch(self.branch.repository,
 
323
                                                    revision_id=self.rev_id)
 
324
                # now the master has the revision data
 
325
                # 'commit' to the master first so a timeout here causes the local
 
326
                # branch to be out of date
 
327
                self.master_branch.append_revision(self.rev_id)
 
328
 
 
329
            # and now do the commit locally.
226
330
            self.branch.append_revision(self.rev_id)
227
 
            self.branch.set_pending_merges([])
 
331
 
 
332
            self.work_tree.set_pending_merges([])
 
333
            self.work_tree.set_last_revision(self.rev_id)
 
334
            # now the work tree is up to date with the branch
 
335
            
 
336
            self.reporter.completed(self.branch.revno(), self.rev_id)
 
337
            if self.config.post_commit() is not None:
 
338
                hooks = self.config.post_commit().split(' ')
 
339
                # this would be nicer with twisted.python.reflect.namedAny
 
340
                for hook in hooks:
 
341
                    result = eval(hook + '(branch, rev_id)',
 
342
                                  {'branch':self.branch,
 
343
                                   'bzrlib':bzrlib,
 
344
                                   'rev_id':self.rev_id})
 
345
            self._emit_progress_update()
228
346
        finally:
229
 
            self.branch.unlock()
230
 
 
231
 
    def _record_inventory(self):
232
 
        """Store the inventory for the new revision."""
233
 
        inv_text = serializer_v5.write_inventory_to_string(self.new_inv)
234
 
        self.inv_sha1 = sha_string(inv_text)
235
 
        s = self.branch.control_weaves
236
 
        s.add_text('inventory', self.rev_id,
237
 
                   split_lines(inv_text), self.present_parents)
 
347
            self._cleanup()
 
348
        return self.rev_id
 
349
 
 
350
    def _check_bound_branch(self):
 
351
        """Check to see if the local branch is bound.
 
352
 
 
353
        If it is bound, then most of the commit will actually be
 
354
        done using the remote branch as the target branch.
 
355
        Only at the end will the local branch be updated.
 
356
        """
 
357
        if self.local and not self.branch.get_bound_location():
 
358
            raise errors.LocalRequiresBoundBranch()
 
359
 
 
360
        if not self.local:
 
361
            self.master_branch = self.branch.get_master_branch()
 
362
 
 
363
        if not self.master_branch:
 
364
            # make this branch the reference branch for out of date checks.
 
365
            self.master_branch = self.branch
 
366
            return
 
367
 
 
368
        # If the master branch is bound, we must fail
 
369
        master_bound_location = self.master_branch.get_bound_location()
 
370
        if master_bound_location:
 
371
            raise errors.CommitToDoubleBoundBranch(self.branch,
 
372
                    self.master_branch, master_bound_location)
 
373
 
 
374
        # TODO: jam 20051230 We could automatically push local
 
375
        #       commits to the remote branch if they would fit.
 
376
        #       But for now, just require remote to be identical
 
377
        #       to local.
 
378
        
 
379
        # Make sure the local branch is identical to the master
 
380
        master_rh = self.master_branch.revision_history()
 
381
        local_rh = self.branch.revision_history()
 
382
        if local_rh != master_rh:
 
383
            raise errors.BoundBranchOutOfDate(self.branch,
 
384
                    self.master_branch)
 
385
 
 
386
        # Now things are ready to change the master branch
 
387
        # so grab the lock
 
388
        self.bound_branch = self.branch
 
389
        self.master_branch.lock_write()
 
390
        self.master_locked = True
 
391
 
 
392
    def _cleanup(self):
 
393
        """Cleanup any open locks, progress bars etc."""
 
394
        cleanups = [self._cleanup_bound_branch,
 
395
                    self.work_tree.unlock,
 
396
                    self.pb.finished]
 
397
        found_exception = None
 
398
        for cleanup in cleanups:
 
399
            try:
 
400
                cleanup()
 
401
            # we want every cleanup to run no matter what.
 
402
            # so we have a catchall here, but we will raise the
 
403
            # last encountered exception up the stack: and
 
404
            # typically this will be useful enough.
 
405
            except Exception, e:
 
406
                found_exception = e
 
407
        if found_exception is not None: 
 
408
            # don't do a plan raise, because the last exception may have been
 
409
            # trashed, e is our sure-to-work exception even though it loses the
 
410
            # full traceback. XXX: RBC 20060421 perhaps we could check the
 
411
            # exc_info and if its the same one do a plain raise otherwise 
 
412
            # 'raise e' as we do now.
 
413
            raise e
 
414
 
 
415
    def _cleanup_bound_branch(self):
 
416
        """Executed at the end of a try/finally to cleanup a bound branch.
 
417
 
 
418
        If the branch wasn't bound, this is a no-op.
 
419
        If it was, it resents self.branch to the local branch, instead
 
420
        of being the master.
 
421
        """
 
422
        if not self.bound_branch:
 
423
            return
 
424
        if self.master_locked:
 
425
            self.master_branch.unlock()
238
426
 
239
427
    def _escape_commit_message(self):
240
428
        """Replace xml-incompatible control characters."""
 
429
        # FIXME: RBC 20060419 this should be done by the revision
 
430
        # serialiser not by commit. Then we can also add an unescaper
 
431
        # in the deserializer and start roundtripping revision messages
 
432
        # precisely. See repository_implementations/test_repository.py
 
433
        
241
434
        # Python strings can include characters that can't be
242
435
        # represented in well-formed XML; escape characters that
243
436
        # aren't listed in the XML specification
244
437
        # (http://www.w3.org/TR/REC-xml/#NT-Char).
245
 
        if isinstance(self.message, unicode):
246
 
            char_pattern = u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]'
247
 
        else:
248
 
            # Use a regular 'str' as pattern to avoid having re.subn
249
 
            # return 'unicode' results.
250
 
            char_pattern = '[^x09\x0A\x0D\x20-\xFF]'
251
438
        self.message, escape_count = re.subn(
252
 
            char_pattern,
 
439
            u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
253
440
            lambda match: match.group(0).encode('unicode_escape'),
254
441
            self.message)
255
442
        if escape_count:
256
 
            note("replaced %d control characters in message", escape_count)
257
 
 
258
 
    def _record_ancestry(self):
259
 
        """Append merged revision ancestry to the ancestry file.
260
 
 
261
 
        This should be the merged ancestry of all parents, plus the
262
 
        new revision id."""
263
 
        s = self.branch.control_weaves
264
 
        w = s.get_weave_or_empty('ancestry')
265
 
        lines = self._make_ancestry(w)
266
 
        w.add(self.rev_id, self.present_parents, lines)
267
 
        s.put_weave('ancestry', w)
268
 
 
269
 
    def _make_ancestry(self, ancestry_weave):
270
 
        """Return merged ancestry lines.
271
 
 
272
 
        The lines are revision-ids followed by newlines."""
273
 
        parent_ancestries = [ancestry_weave.get(p) for p in self.present_parents]
274
 
        new_lines = merge_ancestry_lines(self.rev_id, parent_ancestries)
275
 
        mutter('merged ancestry of {%s}:\n%s', self.rev_id, ''.join(new_lines))
276
 
        return new_lines
 
443
            self.reporter.escaped(escape_count, self.message)
277
444
 
278
445
    def _gather_parents(self):
279
446
        """Record the parents of a merge for merge detection."""
280
 
        pending_merges = self.branch.pending_merges()
281
 
        self.parents = []
 
447
        # TODO: Make sure that this list doesn't contain duplicate 
 
448
        # entries and the order is preserved when doing this.
 
449
        self.parents = self.work_tree.get_parent_ids()
282
450
        self.parent_invs = []
283
 
        self.present_parents = []
284
 
        precursor_id = self.branch.last_revision()
285
 
        if precursor_id:
286
 
            self.parents.append(precursor_id)
287
 
        self.parents += pending_merges
288
451
        for revision in self.parents:
289
 
            if self.branch.has_revision(revision):
290
 
                self.parent_invs.append(self.branch.get_inventory(revision))
291
 
                self.present_parents.append(revision)
 
452
            if self.branch.repository.has_revision(revision):
 
453
                inventory = self.branch.repository.get_inventory(revision)
 
454
                self.parent_invs.append(inventory)
292
455
 
293
456
    def _check_parents_present(self):
294
457
        for parent_id in self.parents:
295
458
            mutter('commit parent revision {%s}', parent_id)
296
 
            if not self.branch.has_revision(parent_id):
 
459
            if not self.branch.repository.has_revision(parent_id):
297
460
                if parent_id == self.branch.last_revision():
298
 
                    warning("parent is pissing %r", parent_id)
299
 
                    raise HistoryMissing(self.branch, 'revision', parent_id)
300
 
                else:
301
 
                    mutter("commit will ghost revision %r", parent_id)
 
461
                    warning("parent is missing %r", parent_id)
 
462
                    raise BzrCheckError("branch %s is missing revision {%s}"
 
463
                            % (self.branch, parent_id))
302
464
            
303
 
    def _make_revision(self):
304
 
        """Record a new revision object for this commit."""
305
 
        self.rev = Revision(timestamp=self.timestamp,
306
 
                            timezone=self.timezone,
307
 
                            committer=self.committer,
308
 
                            message=self.message,
309
 
                            inventory_sha1=self.inv_sha1,
310
 
                            revision_id=self.rev_id)
311
 
        self.rev.parent_ids = self.parents
312
 
        rev_tmp = StringIO()
313
 
        serializer_v5.write_revision(self.rev, rev_tmp)
314
 
        rev_tmp.seek(0)
315
 
        self.branch.revision_store.add(rev_tmp, self.rev_id)
316
 
        mutter('new revision_id is {%s}', self.rev_id)
317
 
 
318
 
 
319
465
    def _remove_deleted(self):
320
466
        """Remove deleted files from the working inventories.
321
467
 
333
479
            if specific and not is_inside_any(specific, path):
334
480
                continue
335
481
            if not self.work_tree.has_filename(path):
336
 
                note('missing %s', path)
337
 
                deleted_ids.append(ie.file_id)
 
482
                self.reporter.missing(path)
 
483
                deleted_ids.append((path, ie.file_id))
338
484
        if deleted_ids:
339
 
            for file_id in deleted_ids:
340
 
                if file_id in self.work_inv:
341
 
                    del self.work_inv[file_id]
342
 
            self.branch._write_inventory(self.work_inv)
343
 
 
344
 
    def _store_snapshot(self):
345
 
        """Pass over inventory and record a snapshot.
346
 
 
347
 
        Entries get a new revision when they are modified in 
348
 
        any way, which includes a merge with a new set of
349
 
        parents that have the same entry. 
350
 
        """
351
 
        # XXX: Need to think more here about when the user has
352
 
        # made a specific decision on a particular value -- c.f.
353
 
        # mark-merge.  
354
 
        for path, ie in self.new_inv.iter_entries():
355
 
            previous_entries = ie.find_previous_heads(
356
 
                self.parent_invs, 
357
 
                self.weave_store.get_weave_or_empty(ie.file_id))
358
 
            if ie.revision is None:
359
 
                change = ie.snapshot(self.rev_id, path, previous_entries,
360
 
                                     self.work_tree, self.weave_store)
361
 
            else:
362
 
                change = "unchanged"
363
 
            note("%s %s", change, path)
 
485
            deleted_ids.sort(reverse=True)
 
486
            for path, file_id in deleted_ids:
 
487
                del self.work_inv[file_id]
 
488
            self.work_tree._write_inventory(self.work_inv)
364
489
 
365
490
    def _populate_new_inv(self):
366
491
        """Build revision inventory.
372
497
        None; inventory entries that are carried over untouched have their
373
498
        revision set to their prior value.
374
499
        """
 
500
        # ESEPARATIONOFCONCERNS: this function is diffing and using the diff
 
501
        # results to create a new inventory at the same time, which results
 
502
        # in bugs like #46635.  Any reason not to use/enhance compare_trees?
 
503
        # ADHB 11-07-2006
375
504
        mutter("Selecting files for commit with filter %s", self.specific_files)
376
 
        self.new_inv = Inventory()
 
505
        # iter_entries does not visit the ROOT_ID node so we need to call
 
506
        # self._emit_progress_update once by hand.
 
507
        self._emit_progress_update()
377
508
        for path, new_ie in self.work_inv.iter_entries():
 
509
            self._emit_progress_update()
378
510
            file_id = new_ie.file_id
379
 
            mutter('check %s {%s}', path, new_ie.file_id)
380
 
            if self.specific_files:
381
 
                if not is_inside_any(self.specific_files, path):
382
 
                    mutter('%s not selected for commit', path)
383
 
                    self._carry_file(file_id)
 
511
            mutter('check %s {%s}', path, file_id)
 
512
            if (not self.specific_files or 
 
513
                is_inside_or_parent_of_any(self.specific_files, path)):
 
514
                    mutter('%s selected for commit', path)
 
515
                    ie = new_ie.copy()
 
516
                    ie.revision = None
 
517
            else:
 
518
                mutter('%s not selected for commit', path)
 
519
                if self.basis_inv.has_id(file_id):
 
520
                    ie = self.basis_inv[file_id].copy()
 
521
                else:
 
522
                    # this entry is new and not being committed
384
523
                    continue
385
 
            mutter('%s selected for commit', path)
 
524
 
 
525
            self.builder.record_entry_contents(ie, self.parent_invs, 
 
526
                path, self.work_tree)
 
527
            # describe the nature of the change that has occurred relative to
 
528
            # the basis inventory.
 
529
            if (self.basis_inv.has_id(ie.file_id)):
 
530
                basis_ie = self.basis_inv[ie.file_id]
 
531
            else:
 
532
                basis_ie = None
 
533
            change = ie.describe_change(basis_ie, ie)
 
534
            if change in (InventoryEntry.RENAMED, 
 
535
                InventoryEntry.MODIFIED_AND_RENAMED):
 
536
                old_path = self.basis_inv.id2path(ie.file_id)
 
537
                self.reporter.renamed(change, old_path, path)
 
538
            else:
 
539
                self.reporter.snapshot_change(change, path)
 
540
 
 
541
        if not self.specific_files:
 
542
            return
 
543
 
 
544
        # ignore removals that don't match filespec
 
545
        for path, new_ie in self.basis_inv.iter_entries():
 
546
            if new_ie.file_id in self.work_inv:
 
547
                continue
 
548
            if is_inside_any(self.specific_files, path):
 
549
                continue
386
550
            ie = new_ie.copy()
387
551
            ie.revision = None
388
 
            self.new_inv.add(ie)
 
552
            self.builder.record_entry_contents(ie, self.parent_invs, path,
 
553
                                               self.basis_tree)
389
554
 
390
 
    def _carry_file(self, file_id):
391
 
        """Carry the file unchanged from the basis revision."""
392
 
        if self.basis_inv.has_id(file_id):
393
 
            self.new_inv.add(self.basis_inv[file_id].copy())
 
555
    def _emit_progress_update(self):
 
556
        """Emit an update to the progress bar."""
 
557
        self.pb.update("Committing", self.pb_count, self.pb_total)
 
558
        self.pb_count += 1
394
559
 
395
560
    def _report_deletes(self):
396
 
        for file_id in self.basis_inv:
397
 
            if file_id not in self.new_inv:
398
 
                note('deleted %s', self.basis_inv.id2path(file_id))
399
 
 
400
 
 
401
 
 
402
 
def _gen_revision_id(branch, when):
403
 
    """Return new revision-id."""
404
 
    s = '%s-%s-' % (user_email(branch), compact_date(when))
405
 
    s += hexlify(rand_bytes(8))
406
 
    return s
407
 
 
408
 
 
409
 
 
410
 
    
411
 
def merge_ancestry_lines(rev_id, ancestries):
412
 
    """Return merged ancestry lines.
413
 
 
414
 
    rev_id -- id of the new revision
415
 
    
416
 
    ancestries -- a sequence of ancestries for parent revisions,
417
 
        as newline-terminated line lists.
418
 
    """
419
 
    if len(ancestries) == 0:
420
 
        return [rev_id + '\n']
421
 
    seen = set(ancestries[0])
422
 
    ancs = ancestries[0][:]    
423
 
    for parent_ancestry in ancestries[1:]:
424
 
        for line in parent_ancestry:
425
 
            assert line[-1] == '\n'
426
 
            if line not in seen:
427
 
                ancs.append(line)
428
 
                seen.add(line)
429
 
    r = rev_id + '\n'
430
 
    assert r not in seen
431
 
    ancs.append(r)
432
 
    return ancs
 
561
        for path, ie in self.basis_inv.iter_entries():
 
562
            if ie.file_id not in self.builder.new_inventory:
 
563
                self.reporter.deleted(path)
 
564
 
 
565