~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2006-06-15 05:36:34 UTC
  • mto: This revision was merged to the branch mainline in revision 1797.
  • Revision ID: mbp@sourcefrog.net-20060615053634-4fd52ba691855659
Clean up many exception classes.

Errors indicating a user error are now shown with is_user_error on the
exception; use this rather than hardcoding a list of exceptions that should be
handled this way.

Exceptions now inherit from BzrNewException where possible to use consistent
formatting method.

Remove rather obsolete docstring test on Branch.missing_revisions.

Remove dead code from find_merge_base.


Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006 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
# XXX: Can we do any better about making interrupted commits change
 
19
# nothing?  Perhaps the best approach is to integrate commit of
 
20
# AtomicFiles with releasing the lock on the Branch.
 
21
 
 
22
# TODO: Separate 'prepare' phase where we find a list of potentially
 
23
# committed files.  We then can then pause the commit to prompt for a
 
24
# commit message, knowing the summary will be the same as what's
 
25
# actually used for the commit.  (But perhaps simpler to simply get
 
26
# the tree status, then use that for a selective commit?)
 
27
 
 
28
# The newly committed revision is going to have a shape corresponding
 
29
# to that of the working inventory.  Files that are not in the
 
30
# working tree and that were in the predecessor are reported as
 
31
# removed --- this can include files that were either removed from the
 
32
# inventory or deleted in the working tree.  If they were only
 
33
# deleted from disk, they are removed from the working inventory.
 
34
 
 
35
# We then consider the remaining entries, which will be in the new
 
36
# version.  Directory entries are simply copied across.  File entries
 
37
# must be checked to see if a new version of the file should be
 
38
# recorded.  For each parent revision inventory, we check to see what
 
39
# version of the file was present.  If the file was present in at
 
40
# least one tree, and if it was the same version in all the trees,
 
41
# then we can just refer to that version.  Otherwise, a new version
 
42
# representing the merger of the file versions must be added.
 
43
 
 
44
# TODO: Update hashcache before and after - or does the WorkingTree
 
45
# look after that?
 
46
 
 
47
# TODO: Rather than mashing together the ancestry and storing it back,
 
48
# perhaps the weave should have single method which does it all in one
 
49
# go, avoiding a lot of redundant work.
 
50
 
 
51
# TODO: Perhaps give a warning if one of the revisions marked as
 
52
# merged is already in the ancestry, and then don't record it as a
 
53
# distinct parent.
 
54
 
 
55
# TODO: If the file is newly merged but unchanged from the version it
 
56
# merges from, then it should still be reported as newly added
 
57
# relative to the basis revision.
 
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
 
 
65
 
 
66
import os
 
67
import re
 
68
import sys
 
69
import time
 
70
import pdb
 
71
 
 
72
from binascii import hexlify
 
73
from cStringIO import StringIO
 
74
 
 
75
from bzrlib.atomicfile import AtomicFile
 
76
from bzrlib.osutils import (local_time_offset,
 
77
                            rand_bytes, compact_date,
 
78
                            kind_marker, is_inside_any, quotefn,
 
79
                            sha_file, isdir, isfile,
 
80
                            split_lines)
 
81
import bzrlib.config
 
82
import bzrlib.errors as errors
 
83
from bzrlib.errors import (BzrError, PointlessCommit,
 
84
                           ConflictsInTree,
 
85
                           StrictCommitFailed
 
86
                           )
 
87
from bzrlib.revision import Revision
 
88
from bzrlib.testament import Testament
 
89
from bzrlib.trace import mutter, note, warning
 
90
from bzrlib.xml5 import serializer_v5
 
91
from bzrlib.inventory import Inventory, ROOT_ID, InventoryEntry
 
92
from bzrlib.symbol_versioning import *
 
93
from bzrlib.workingtree import WorkingTree
 
94
 
 
95
 
 
96
@deprecated_function(zero_seven)
 
97
def commit(*args, **kwargs):
 
98
    """Commit a new revision to a branch.
 
99
 
 
100
    Function-style interface for convenience of old callers.
 
101
 
 
102
    New code should use the Commit class instead.
 
103
    """
 
104
    ## XXX: Remove this in favor of Branch.commit?
 
105
    Commit().commit(*args, **kwargs)
 
106
 
 
107
 
 
108
class NullCommitReporter(object):
 
109
    """I report on progress of a commit."""
 
110
 
 
111
    def snapshot_change(self, change, path):
 
112
        pass
 
113
 
 
114
    def completed(self, revno, rev_id):
 
115
        pass
 
116
 
 
117
    def deleted(self, file_id):
 
118
        pass
 
119
 
 
120
    def escaped(self, escape_count, message):
 
121
        pass
 
122
 
 
123
    def missing(self, path):
 
124
        pass
 
125
 
 
126
    def renamed(self, change, old_path, new_path):
 
127
        pass
 
128
 
 
129
 
 
130
class ReportCommitToLog(NullCommitReporter):
 
131
 
 
132
    # this may be more useful if 'note' was replaced by an overridable
 
133
    # method on self, which would allow more trivial subclassing.
 
134
    # alternative, a callable could be passed in, allowing really trivial
 
135
    # reuse for some uis. RBC 20060511
 
136
 
 
137
    def snapshot_change(self, change, path):
 
138
        if change == 'unchanged':
 
139
            return
 
140
        note("%s %s", change, path)
 
141
 
 
142
    def completed(self, revno, rev_id):
 
143
        note('Committed revision %d.', revno)
 
144
    
 
145
    def deleted(self, file_id):
 
146
        note('deleted %s', file_id)
 
147
 
 
148
    def escaped(self, escape_count, message):
 
149
        note("replaced %d control characters in message", escape_count)
 
150
 
 
151
    def missing(self, path):
 
152
        note('missing %s', path)
 
153
 
 
154
    def renamed(self, change, old_path, new_path):
 
155
        note('%s %s => %s', change, old_path, new_path)
 
156
 
 
157
 
 
158
class Commit(object):
 
159
    """Task of committing a new revision.
 
160
 
 
161
    This is a MethodObject: it accumulates state as the commit is
 
162
    prepared, and then it is discarded.  It doesn't represent
 
163
    historical revisions, just the act of recording a new one.
 
164
 
 
165
            missing_ids
 
166
            Modified to hold a list of files that have been deleted from
 
167
            the working directory; these should be removed from the
 
168
            working inventory.
 
169
    """
 
170
    def __init__(self,
 
171
                 reporter=None,
 
172
                 config=None):
 
173
        if reporter is not None:
 
174
            self.reporter = reporter
 
175
        else:
 
176
            self.reporter = NullCommitReporter()
 
177
        if config is not None:
 
178
            self.config = config
 
179
        else:
 
180
            self.config = None
 
181
        
 
182
    def commit(self,
 
183
               branch=DEPRECATED_PARAMETER, message=None,
 
184
               timestamp=None,
 
185
               timezone=None,
 
186
               committer=None,
 
187
               specific_files=None,
 
188
               rev_id=None,
 
189
               allow_pointless=True,
 
190
               strict=False,
 
191
               verbose=False,
 
192
               revprops=None,
 
193
               working_tree=None,
 
194
               local=False,
 
195
               reporter=None,
 
196
               config=None):
 
197
        """Commit working copy as a new revision.
 
198
 
 
199
        branch -- the deprecated branch to commit to. New callers should pass in 
 
200
                  working_tree instead
 
201
 
 
202
        message -- the commit message, a mandatory parameter
 
203
 
 
204
        timestamp -- if not None, seconds-since-epoch for a
 
205
             postdated/predated commit.
 
206
 
 
207
        specific_files -- If true, commit only those files.
 
208
 
 
209
        rev_id -- If set, use this as the new revision id.
 
210
            Useful for test or import commands that need to tightly
 
211
            control what revisions are assigned.  If you duplicate
 
212
            a revision id that exists elsewhere it is your own fault.
 
213
            If null (default), a time/random revision id is generated.
 
214
 
 
215
        allow_pointless -- If true (default), commit even if nothing
 
216
            has changed and no merges are recorded.
 
217
 
 
218
        strict -- If true, don't allow a commit if the working tree
 
219
            contains unknown files.
 
220
 
 
221
        revprops -- Properties for new revision
 
222
        :param local: Perform a local only commit.
 
223
        """
 
224
        mutter('preparing to commit')
 
225
 
 
226
        if deprecated_passed(branch):
 
227
            warn("Commit.commit (branch, ...): The branch parameter is "
 
228
                 "deprecated as of bzr 0.8. Please use working_tree= instead.",
 
229
                 DeprecationWarning, stacklevel=2)
 
230
            self.branch = branch
 
231
            self.work_tree = self.branch.bzrdir.open_workingtree()
 
232
        elif working_tree is None:
 
233
            raise BzrError("One of branch and working_tree must be passed into commit().")
 
234
        else:
 
235
            self.work_tree = working_tree
 
236
            self.branch = self.work_tree.branch
 
237
        if message is None:
 
238
            raise BzrError("The message keyword parameter is required for commit().")
 
239
 
 
240
        self.weave_store = self.branch.repository.weave_store
 
241
        self.bound_branch = None
 
242
        self.local = local
 
243
        self.master_branch = None
 
244
        self.master_locked = False
 
245
        self.rev_id = rev_id
 
246
        self.specific_files = specific_files
 
247
        self.allow_pointless = allow_pointless
 
248
        self.revprops = {}
 
249
        if revprops is not None:
 
250
            self.revprops.update(revprops)
 
251
 
 
252
        if reporter is None and self.reporter is None:
 
253
            self.reporter = NullCommitReporter()
 
254
        elif reporter is not None:
 
255
            self.reporter = reporter
 
256
 
 
257
        self.work_tree.lock_write()
 
258
        self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
259
        try:
 
260
            # Cannot commit with conflicts present.
 
261
            if len(self.work_tree.conflicts())>0:
 
262
                raise ConflictsInTree
 
263
 
 
264
            # setup the bound branch variables as needed.
 
265
            self._check_bound_branch()
 
266
 
 
267
            # check for out of date working trees
 
268
            # if we are bound, then self.branch is the master branch and this
 
269
            # test is thus all we need.
 
270
            if self.work_tree.last_revision() != self.master_branch.last_revision():
 
271
                raise errors.OutOfDateTree(self.work_tree)
 
272
    
 
273
            if strict:
 
274
                # raise an exception as soon as we find a single unknown.
 
275
                for unknown in self.work_tree.unknowns():
 
276
                    raise StrictCommitFailed()
 
277
    
 
278
            if timestamp is None:
 
279
                self.timestamp = time.time()
 
280
            else:
 
281
                self.timestamp = long(timestamp)
 
282
                
 
283
            if self.config is None:
 
284
                self.config = bzrlib.config.BranchConfig(self.branch)
 
285
    
 
286
            if rev_id is None:
 
287
                self.rev_id = _gen_revision_id(self.config, self.timestamp)
 
288
            else:
 
289
                self.rev_id = rev_id
 
290
    
 
291
            if committer is None:
 
292
                self.committer = self.config.username()
 
293
            else:
 
294
                assert isinstance(committer, basestring), type(committer)
 
295
                self.committer = committer
 
296
    
 
297
            if timezone is None:
 
298
                self.timezone = local_time_offset()
 
299
            else:
 
300
                self.timezone = int(timezone)
 
301
    
 
302
            if isinstance(message, str):
 
303
                message = message.decode(bzrlib.user_encoding)
 
304
            assert isinstance(message, unicode), type(message)
 
305
            self.message = message
 
306
            self._escape_commit_message()
 
307
 
 
308
            self.work_inv = self.work_tree.inventory
 
309
            self.basis_tree = self.work_tree.basis_tree()
 
310
            self.basis_inv = self.basis_tree.inventory
 
311
            # one to finish, one for rev and inventory, and one for each
 
312
            # inventory entry, and the same for the new inventory.
 
313
            # note that this estimate is too long when we do a partial tree
 
314
            # commit which excludes some new files from being considered.
 
315
            # The estimate is corrected when we populate the new inv.
 
316
            self.pb_total = len(self.basis_inv) + len(self.work_inv) + 3 - 1
 
317
            self.pb_count = 0
 
318
 
 
319
            self._gather_parents()
 
320
            if len(self.parents) > 1 and self.specific_files:
 
321
                raise NotImplementedError('selected-file commit of merges is not supported yet: files %r',
 
322
                        self.specific_files)
 
323
            self._check_parents_present()
 
324
            
 
325
            self._remove_deleted()
 
326
            self._populate_new_inv()
 
327
            self._store_snapshot()
 
328
            self._report_deletes()
 
329
 
 
330
            if not (self.allow_pointless
 
331
                    or len(self.parents) > 1
 
332
                    or self.new_inv != self.basis_inv):
 
333
                raise PointlessCommit()
 
334
 
 
335
            self._emit_progress_update()
 
336
            self.inv_sha1 = self.branch.repository.add_inventory(
 
337
                self.rev_id,
 
338
                self.new_inv,
 
339
                self.present_parents
 
340
                )
 
341
            self._emit_progress_update()
 
342
            self._make_revision()
 
343
            # revision data is in the local branch now.
 
344
            
 
345
            # upload revision data to the master.
 
346
            # this will propogate merged revisions too if needed.
 
347
            if self.bound_branch:
 
348
                self.master_branch.repository.fetch(self.branch.repository,
 
349
                                                    revision_id=self.rev_id)
 
350
                # now the master has the revision data
 
351
                # 'commit' to the master first so a timeout here causes the local
 
352
                # branch to be out of date
 
353
                self.master_branch.append_revision(self.rev_id)
 
354
 
 
355
            # and now do the commit locally.
 
356
            self.branch.append_revision(self.rev_id)
 
357
 
 
358
            self.work_tree.set_pending_merges([])
 
359
            self.work_tree.set_last_revision(self.rev_id)
 
360
            # now the work tree is up to date with the branch
 
361
            
 
362
            self.reporter.completed(self.branch.revno(), self.rev_id)
 
363
            if self.config.post_commit() is not None:
 
364
                hooks = self.config.post_commit().split(' ')
 
365
                # this would be nicer with twisted.python.reflect.namedAny
 
366
                for hook in hooks:
 
367
                    result = eval(hook + '(branch, rev_id)',
 
368
                                  {'branch':self.branch,
 
369
                                   'bzrlib':bzrlib,
 
370
                                   'rev_id':self.rev_id})
 
371
            self._emit_progress_update()
 
372
        finally:
 
373
            self._cleanup()
 
374
 
 
375
    def _check_bound_branch(self):
 
376
        """Check to see if the local branch is bound.
 
377
 
 
378
        If it is bound, then most of the commit will actually be
 
379
        done using the remote branch as the target branch.
 
380
        Only at the end will the local branch be updated.
 
381
        """
 
382
        if self.local and not self.branch.get_bound_location():
 
383
            raise errors.LocalRequiresBoundBranch()
 
384
 
 
385
        if not self.local:
 
386
            self.master_branch = self.branch.get_master_branch()
 
387
 
 
388
        if not self.master_branch:
 
389
            # make this branch the reference branch for out of date checks.
 
390
            self.master_branch = self.branch
 
391
            return
 
392
 
 
393
        # If the master branch is bound, we must fail
 
394
        master_bound_location = self.master_branch.get_bound_location()
 
395
        if master_bound_location:
 
396
            raise errors.CommitToDoubleBoundBranch(self.branch,
 
397
                    self.master_branch, master_bound_location)
 
398
 
 
399
        # TODO: jam 20051230 We could automatically push local
 
400
        #       commits to the remote branch if they would fit.
 
401
        #       But for now, just require remote to be identical
 
402
        #       to local.
 
403
        
 
404
        # Make sure the local branch is identical to the master
 
405
        master_rh = self.master_branch.revision_history()
 
406
        local_rh = self.branch.revision_history()
 
407
        if local_rh != master_rh:
 
408
            raise errors.BoundBranchOutOfDate(self.branch,
 
409
                    self.master_branch)
 
410
 
 
411
        # Now things are ready to change the master branch
 
412
        # so grab the lock
 
413
        self.bound_branch = self.branch
 
414
        self.master_branch.lock_write()
 
415
        self.master_locked = True
 
416
####        
 
417
####        # Check to see if we have any pending merges. If we do
 
418
####        # those need to be pushed into the master branch
 
419
####        pending_merges = self.work_tree.pending_merges()
 
420
####        if pending_merges:
 
421
####            for revision_id in pending_merges:
 
422
####                self.master_branch.repository.fetch(self.bound_branch.repository,
 
423
####                                                    revision_id=revision_id)
 
424
 
 
425
    def _cleanup(self):
 
426
        """Cleanup any open locks, progress bars etc."""
 
427
        cleanups = [self._cleanup_bound_branch,
 
428
                    self.work_tree.unlock,
 
429
                    self.pb.finished]
 
430
        found_exception = None
 
431
        for cleanup in cleanups:
 
432
            try:
 
433
                cleanup()
 
434
            # we want every cleanup to run no matter what.
 
435
            # so we have a catchall here, but we will raise the
 
436
            # last encountered exception up the stack: and
 
437
            # typically this will be useful enough.
 
438
            except Exception, e:
 
439
                found_exception = e
 
440
        if found_exception is not None: 
 
441
            # dont do a plan raise, because the last exception may have been
 
442
            # trashed, e is our sure-to-work exception even though it loses the
 
443
            # full traceback. XXX: RBC 20060421 perhaps we could check the
 
444
            # exc_info and if its the same one do a plain raise otherwise 
 
445
            # 'raise e' as we do now.
 
446
            raise e
 
447
 
 
448
    def _cleanup_bound_branch(self):
 
449
        """Executed at the end of a try/finally to cleanup a bound branch.
 
450
 
 
451
        If the branch wasn't bound, this is a no-op.
 
452
        If it was, it resents self.branch to the local branch, instead
 
453
        of being the master.
 
454
        """
 
455
        if not self.bound_branch:
 
456
            return
 
457
        if self.master_locked:
 
458
            self.master_branch.unlock()
 
459
 
 
460
    def _escape_commit_message(self):
 
461
        """Replace xml-incompatible control characters."""
 
462
        # FIXME: RBC 20060419 this should be done by the revision
 
463
        # serialiser not by commit. Then we can also add an unescaper
 
464
        # in the deserializer and start roundtripping revision messages
 
465
        # precisely. See repository_implementations/test_repository.py
 
466
        
 
467
        # Python strings can include characters that can't be
 
468
        # represented in well-formed XML; escape characters that
 
469
        # aren't listed in the XML specification
 
470
        # (http://www.w3.org/TR/REC-xml/#NT-Char).
 
471
        self.message, escape_count = re.subn(
 
472
            u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
 
473
            lambda match: match.group(0).encode('unicode_escape'),
 
474
            self.message)
 
475
        if escape_count:
 
476
            self.reporter.escaped(escape_count, self.message)
 
477
 
 
478
    def _gather_parents(self):
 
479
        """Record the parents of a merge for merge detection."""
 
480
        pending_merges = self.work_tree.pending_merges()
 
481
        self.parents = []
 
482
        self.parent_invs = []
 
483
        self.present_parents = []
 
484
        precursor_id = self.branch.last_revision()
 
485
        if precursor_id:
 
486
            self.parents.append(precursor_id)
 
487
        self.parents += pending_merges
 
488
        for revision in self.parents:
 
489
            if self.branch.repository.has_revision(revision):
 
490
                inventory = self.branch.repository.get_inventory(revision)
 
491
                self.parent_invs.append(inventory)
 
492
                self.present_parents.append(revision)
 
493
 
 
494
    def _check_parents_present(self):
 
495
        for parent_id in self.parents:
 
496
            mutter('commit parent revision {%s}', parent_id)
 
497
            if not self.branch.repository.has_revision(parent_id):
 
498
                if parent_id == self.branch.last_revision():
 
499
                    warning("parent is missing %r", parent_id)
 
500
                    raise BzrCheckError("branch %s is missing revision {%s}"
 
501
                            % (self.branch, parent_id))
 
502
            
 
503
    def _make_revision(self):
 
504
        """Record a new revision object for this commit."""
 
505
        rev = Revision(timestamp=self.timestamp,
 
506
                       timezone=self.timezone,
 
507
                       committer=self.committer,
 
508
                       message=self.message,
 
509
                       inventory_sha1=self.inv_sha1,
 
510
                       revision_id=self.rev_id,
 
511
                       properties=self.revprops)
 
512
        rev.parent_ids = self.parents
 
513
        self.branch.repository.add_revision(self.rev_id, rev, self.new_inv, self.config)
 
514
 
 
515
    def _remove_deleted(self):
 
516
        """Remove deleted files from the working inventories.
 
517
 
 
518
        This is done prior to taking the working inventory as the
 
519
        basis for the new committed inventory.
 
520
 
 
521
        This returns true if any files
 
522
        *that existed in the basis inventory* were deleted.
 
523
        Files that were added and deleted
 
524
        in the working copy don't matter.
 
525
        """
 
526
        specific = self.specific_files
 
527
        deleted_ids = []
 
528
        for path, ie in self.work_inv.iter_entries():
 
529
            if specific and not is_inside_any(specific, path):
 
530
                continue
 
531
            if not self.work_tree.has_filename(path):
 
532
                self.reporter.missing(path)
 
533
                deleted_ids.append((path, ie.file_id))
 
534
        if deleted_ids:
 
535
            deleted_ids.sort(reverse=True)
 
536
            for path, file_id in deleted_ids:
 
537
                del self.work_inv[file_id]
 
538
            self.work_tree._write_inventory(self.work_inv)
 
539
 
 
540
    def _store_snapshot(self):
 
541
        """Pass over inventory and record a snapshot.
 
542
 
 
543
        Entries get a new revision when they are modified in 
 
544
        any way, which includes a merge with a new set of
 
545
        parents that have the same entry. 
 
546
        """
 
547
        # XXX: Need to think more here about when the user has
 
548
        # made a specific decision on a particular value -- c.f.
 
549
        # mark-merge.  
 
550
 
 
551
        # iter_entries does not visit the ROOT_ID node so we need to call
 
552
        # self._emit_progress_update once by hand.
 
553
        self._emit_progress_update()
 
554
        for path, ie in self.new_inv.iter_entries():
 
555
            self._emit_progress_update()
 
556
            previous_entries = ie.find_previous_heads(
 
557
                self.parent_invs,
 
558
                self.weave_store,
 
559
                self.branch.repository.get_transaction())
 
560
            if ie.revision is None:
 
561
                # we are creating a new revision for ie in the history store
 
562
                # and inventory.
 
563
                ie.snapshot(self.rev_id, path, previous_entries,
 
564
                    self.work_tree, self.weave_store,
 
565
                    self.branch.repository.get_transaction())
 
566
            # describe the nature of the change that has occured relative to
 
567
            # the basis inventory.
 
568
            if (self.basis_inv.has_id(ie.file_id)):
 
569
                basis_ie = self.basis_inv[ie.file_id]
 
570
            else:
 
571
                basis_ie = None
 
572
            change = ie.describe_change(basis_ie, ie)
 
573
            if change in (InventoryEntry.RENAMED, 
 
574
                InventoryEntry.MODIFIED_AND_RENAMED):
 
575
                old_path = self.basis_inv.id2path(ie.file_id)
 
576
                self.reporter.renamed(change, old_path, path)
 
577
            else:
 
578
                self.reporter.snapshot_change(change, path)
 
579
 
 
580
    def _populate_new_inv(self):
 
581
        """Build revision inventory.
 
582
 
 
583
        This creates a new empty inventory. Depending on
 
584
        which files are selected for commit, and what is present in the
 
585
        current tree, the new inventory is populated. inventory entries 
 
586
        which are candidates for modification have their revision set to
 
587
        None; inventory entries that are carried over untouched have their
 
588
        revision set to their prior value.
 
589
        """
 
590
        mutter("Selecting files for commit with filter %s", self.specific_files)
 
591
        self.new_inv = Inventory(revision_id=self.rev_id)
 
592
        # iter_entries does not visit the ROOT_ID node so we need to call
 
593
        # self._emit_progress_update once by hand.
 
594
        self._emit_progress_update()
 
595
        for path, new_ie in self.work_inv.iter_entries():
 
596
            self._emit_progress_update()
 
597
            file_id = new_ie.file_id
 
598
            mutter('check %s {%s}', path, new_ie.file_id)
 
599
            if self.specific_files:
 
600
                if not is_inside_any(self.specific_files, path):
 
601
                    mutter('%s not selected for commit', path)
 
602
                    self._carry_entry(file_id)
 
603
                    continue
 
604
                else:
 
605
                    # this is selected, ensure its parents are too.
 
606
                    parent_id = new_ie.parent_id
 
607
                    while parent_id != ROOT_ID:
 
608
                        if not self.new_inv.has_id(parent_id):
 
609
                            ie = self._select_entry(self.work_inv[parent_id])
 
610
                            mutter('%s selected for commit because of %s',
 
611
                                   self.new_inv.id2path(parent_id), path)
 
612
 
 
613
                        ie = self.new_inv[parent_id]
 
614
                        if ie.revision is not None:
 
615
                            ie.revision = None
 
616
                            mutter('%s selected for commit because of %s',
 
617
                                   self.new_inv.id2path(parent_id), path)
 
618
                        parent_id = ie.parent_id
 
619
            mutter('%s selected for commit', path)
 
620
            self._select_entry(new_ie)
 
621
 
 
622
    def _emit_progress_update(self):
 
623
        """Emit an update to the progress bar."""
 
624
        self.pb.update("Committing", self.pb_count, self.pb_total)
 
625
        self.pb_count += 1
 
626
 
 
627
    def _select_entry(self, new_ie):
 
628
        """Make new_ie be considered for committing."""
 
629
        ie = new_ie.copy()
 
630
        ie.revision = None
 
631
        self.new_inv.add(ie)
 
632
        return ie
 
633
 
 
634
    def _carry_entry(self, file_id):
 
635
        """Carry the file unchanged from the basis revision."""
 
636
        if self.basis_inv.has_id(file_id):
 
637
            self.new_inv.add(self.basis_inv[file_id].copy())
 
638
        else:
 
639
            # this entry is new and not being committed
 
640
            self.pb_total -= 1
 
641
 
 
642
    def _report_deletes(self):
 
643
        for path, ie in self.basis_inv.iter_entries():
 
644
            if ie.file_id not in self.new_inv:
 
645
                self.reporter.deleted(path)
 
646
 
 
647
def _gen_revision_id(config, when):
 
648
    """Return new revision-id."""
 
649
    s = '%s-%s-' % (config.user_email(), compact_date(when))
 
650
    s += hexlify(rand_bytes(8))
 
651
    return s