~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-09-01 17:29:56 UTC
  • mfrom: (1711.9.14 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060901172956-71246cfb9bf153f8
(vila) cleanup http changes

Show diffs side-by-side

added added

removed removed

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