/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: holger krekel
  • Date: 2006-08-12 15:56:40 UTC
  • mto: (1908.3.21 usecases-benchmarks)
  • mto: This revision was merged to the branch mainline in revision 2068.
  • Revision ID: hpk@merlinux.de-20060812155640-8306a30158d2c5fe
Explicitely generate test functions. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commit.py
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
 
69
import warnings
71
70
 
72
 
from binascii import hexlify
73
71
from cStringIO import StringIO
74
72
 
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
73
import bzrlib.config
82
74
import bzrlib.errors as errors
83
75
from bzrlib.errors import (BzrError, PointlessCommit,
84
 
                           HistoryMissing,
85
76
                           ConflictsInTree,
86
77
                           StrictCommitFailed
87
78
                           )
88
 
from bzrlib.revision import Revision
 
79
from bzrlib.osutils import (kind_marker, isdir,isfile, is_inside_any, 
 
80
                            is_inside_or_parent_of_any,
 
81
                            quotefn, sha_file, split_lines)
89
82
from bzrlib.testament import Testament
90
83
from bzrlib.trace import mutter, note, warning
91
84
from bzrlib.xml5 import serializer_v5
92
 
from bzrlib.inventory import Inventory, ROOT_ID
93
 
from bzrlib.symbol_versioning import *
 
85
from bzrlib.inventory import Inventory, ROOT_ID, InventoryEntry
 
86
from bzrlib.symbol_versioning import (deprecated_passed,
 
87
        deprecated_function,
 
88
        zero_seven,
 
89
        DEPRECATED_PARAMETER)
94
90
from bzrlib.workingtree import WorkingTree
95
91
 
96
92
 
102
98
 
103
99
    New code should use the Commit class instead.
104
100
    """
105
 
    ## XXX: Remove this in favor of Branch.commit?
 
101
    ## XXX: Remove this in favor of WorkingTree.commit?
106
102
    Commit().commit(*args, **kwargs)
107
103
 
108
104
 
124
120
    def missing(self, path):
125
121
        pass
126
122
 
 
123
    def renamed(self, change, old_path, new_path):
 
124
        pass
 
125
 
127
126
 
128
127
class ReportCommitToLog(NullCommitReporter):
129
128
 
 
129
    # this may be more useful if 'note' was replaced by an overridable
 
130
    # method on self, which would allow more trivial subclassing.
 
131
    # alternative, a callable could be passed in, allowing really trivial
 
132
    # reuse for some uis. RBC 20060511
 
133
 
130
134
    def snapshot_change(self, change, path):
131
135
        if change == 'unchanged':
132
136
            return
144
148
    def missing(self, path):
145
149
        note('missing %s', path)
146
150
 
 
151
    def renamed(self, change, old_path, new_path):
 
152
        note('%s %s => %s', change, old_path, new_path)
 
153
 
147
154
 
148
155
class Commit(object):
149
156
    """Task of committing a new revision.
214
221
        mutter('preparing to commit')
215
222
 
216
223
        if deprecated_passed(branch):
217
 
            warn("Commit.commit (branch, ...): The branch parameter is "
 
224
            warnings.warn("Commit.commit (branch, ...): The branch parameter is "
218
225
                 "deprecated as of bzr 0.8. Please use working_tree= instead.",
219
226
                 DeprecationWarning, stacklevel=2)
220
227
            self.branch = branch
227
234
        if message is None:
228
235
            raise BzrError("The message keyword parameter is required for commit().")
229
236
 
230
 
        self.weave_store = self.branch.repository.weave_store
231
237
        self.bound_branch = None
232
238
        self.local = local
233
239
        self.master_branch = None
234
240
        self.master_locked = False
235
 
        self.rev_id = rev_id
 
241
        self.rev_id = None
236
242
        self.specific_files = specific_files
237
243
        self.allow_pointless = allow_pointless
238
 
        self.revprops = {}
239
 
        if revprops is not None:
240
 
            self.revprops.update(revprops)
241
244
 
242
245
        if reporter is None and self.reporter is None:
243
246
            self.reporter = NullCommitReporter()
245
248
            self.reporter = reporter
246
249
 
247
250
        self.work_tree.lock_write()
 
251
        self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
248
252
        try:
 
253
            # Cannot commit with conflicts present.
 
254
            if len(self.work_tree.conflicts())>0:
 
255
                raise ConflictsInTree
 
256
 
249
257
            # setup the bound branch variables as needed.
250
258
            self._check_bound_branch()
251
259
 
259
267
                # raise an exception as soon as we find a single unknown.
260
268
                for unknown in self.work_tree.unknowns():
261
269
                    raise StrictCommitFailed()
262
 
    
263
 
            if timestamp is None:
264
 
                self.timestamp = time.time()
265
 
            else:
266
 
                self.timestamp = long(timestamp)
267
 
                
 
270
                   
268
271
            if self.config is None:
269
 
                self.config = bzrlib.config.BranchConfig(self.branch)
270
 
    
271
 
            if rev_id is None:
272
 
                self.rev_id = _gen_revision_id(self.config, self.timestamp)
273
 
            else:
274
 
                self.rev_id = rev_id
275
 
    
276
 
            if committer is None:
277
 
                self.committer = self.config.username()
278
 
            else:
279
 
                assert isinstance(committer, basestring), type(committer)
280
 
                self.committer = committer
281
 
    
282
 
            if timezone is None:
283
 
                self.timezone = local_time_offset()
284
 
            else:
285
 
                self.timezone = int(timezone)
286
 
    
 
272
                self.config = self.branch.get_config()
 
273
      
287
274
            if isinstance(message, str):
288
275
                message = message.decode(bzrlib.user_encoding)
289
276
            assert isinstance(message, unicode), type(message)
293
280
            self.work_inv = self.work_tree.inventory
294
281
            self.basis_tree = self.work_tree.basis_tree()
295
282
            self.basis_inv = self.basis_tree.inventory
 
283
            # one to finish, one for rev and inventory, and one for each
 
284
            # inventory entry, and the same for the new inventory.
 
285
            # note that this estimate is too long when we do a partial tree
 
286
            # commit which excludes some new files from being considered.
 
287
            # The estimate is corrected when we populate the new inv.
 
288
            self.pb_total = len(self.work_inv) + 5
 
289
            self.pb_count = 0
296
290
 
297
291
            self._gather_parents()
298
292
            if len(self.parents) > 1 and self.specific_files:
299
 
                raise NotImplementedError('selected-file commit of merges is not supported yet')
 
293
                raise NotImplementedError('selected-file commit of merges is not supported yet: files %r',
 
294
                        self.specific_files)
300
295
            self._check_parents_present()
 
296
            self.builder = self.branch.get_commit_builder(self.parents, 
 
297
                self.config, timestamp, timezone, committer, revprops, rev_id)
301
298
            
302
299
            self._remove_deleted()
303
300
            self._populate_new_inv()
304
 
            self._store_snapshot()
305
301
            self._report_deletes()
306
302
 
307
303
            if not (self.allow_pointless
308
304
                    or len(self.parents) > 1
309
 
                    or self.new_inv != self.basis_inv):
 
305
                    or self.builder.new_inventory != self.basis_inv):
310
306
                raise PointlessCommit()
311
307
 
312
 
            if len(self.work_tree.conflicts())>0:
313
 
                raise ConflictsInTree
314
 
 
315
 
            self.inv_sha1 = self.branch.repository.add_inventory(
316
 
                self.rev_id,
317
 
                self.new_inv,
318
 
                self.present_parents
319
 
                )
320
 
            self._make_revision()
 
308
            self._emit_progress_update()
 
309
            # TODO: Now the new inventory is known, check for conflicts and prompt the 
 
310
            # user for a commit message.
 
311
            self.builder.finish_inventory()
 
312
            self._emit_progress_update()
 
313
            self.rev_id = self.builder.commit(self.message)
 
314
            self._emit_progress_update()
321
315
            # revision data is in the local branch now.
322
316
            
323
317
            # upload revision data to the master.
324
 
            # this will propogate merged revisions too if needed.
 
318
            # this will propagate merged revisions too if needed.
325
319
            if self.bound_branch:
326
320
                self.master_branch.repository.fetch(self.branch.repository,
327
321
                                                    revision_id=self.rev_id)
346
340
                                  {'branch':self.branch,
347
341
                                   'bzrlib':bzrlib,
348
342
                                   'rev_id':self.rev_id})
 
343
            self._emit_progress_update()
349
344
        finally:
350
 
            self._cleanup_bound_branch()
351
 
            self.work_tree.unlock()
 
345
            self._cleanup()
 
346
        return self.rev_id
352
347
 
353
348
    def _check_bound_branch(self):
354
349
        """Check to see if the local branch is bound.
391
386
        self.bound_branch = self.branch
392
387
        self.master_branch.lock_write()
393
388
        self.master_locked = True
394
 
####        
395
 
####        # Check to see if we have any pending merges. If we do
396
 
####        # those need to be pushed into the master branch
397
 
####        pending_merges = self.work_tree.pending_merges()
398
 
####        if pending_merges:
399
 
####            for revision_id in pending_merges:
400
 
####                self.master_branch.repository.fetch(self.bound_branch.repository,
401
 
####                                                    revision_id=revision_id)
 
389
 
 
390
    def _cleanup(self):
 
391
        """Cleanup any open locks, progress bars etc."""
 
392
        cleanups = [self._cleanup_bound_branch,
 
393
                    self.work_tree.unlock,
 
394
                    self.pb.finished]
 
395
        found_exception = None
 
396
        for cleanup in cleanups:
 
397
            try:
 
398
                cleanup()
 
399
            # we want every cleanup to run no matter what.
 
400
            # so we have a catchall here, but we will raise the
 
401
            # last encountered exception up the stack: and
 
402
            # typically this will be useful enough.
 
403
            except Exception, e:
 
404
                found_exception = e
 
405
        if found_exception is not None: 
 
406
            # don't do a plan raise, because the last exception may have been
 
407
            # trashed, e is our sure-to-work exception even though it loses the
 
408
            # full traceback. XXX: RBC 20060421 perhaps we could check the
 
409
            # exc_info and if its the same one do a plain raise otherwise 
 
410
            # 'raise e' as we do now.
 
411
            raise e
402
412
 
403
413
    def _cleanup_bound_branch(self):
404
414
        """Executed at the end of a try/finally to cleanup a bound branch.
414
424
 
415
425
    def _escape_commit_message(self):
416
426
        """Replace xml-incompatible control characters."""
 
427
        # FIXME: RBC 20060419 this should be done by the revision
 
428
        # serialiser not by commit. Then we can also add an unescaper
 
429
        # in the deserializer and start roundtripping revision messages
 
430
        # precisely. See repository_implementations/test_repository.py
 
431
        
417
432
        # Python strings can include characters that can't be
418
433
        # represented in well-formed XML; escape characters that
419
434
        # aren't listed in the XML specification
427
442
 
428
443
    def _gather_parents(self):
429
444
        """Record the parents of a merge for merge detection."""
430
 
        pending_merges = self.work_tree.pending_merges()
431
 
        self.parents = []
 
445
        # TODO: Make sure that this list doesn't contain duplicate 
 
446
        # entries and the order is preserved when doing this.
 
447
        self.parents = self.work_tree.get_parent_ids()
432
448
        self.parent_invs = []
433
 
        self.present_parents = []
434
 
        precursor_id = self.branch.last_revision()
435
 
        if precursor_id:
436
 
            self.parents.append(precursor_id)
437
 
        self.parents += pending_merges
438
449
        for revision in self.parents:
439
450
            if self.branch.repository.has_revision(revision):
440
451
                inventory = self.branch.repository.get_inventory(revision)
441
452
                self.parent_invs.append(inventory)
442
 
                self.present_parents.append(revision)
443
453
 
444
454
    def _check_parents_present(self):
445
455
        for parent_id in self.parents:
447
457
            if not self.branch.repository.has_revision(parent_id):
448
458
                if parent_id == self.branch.last_revision():
449
459
                    warning("parent is missing %r", parent_id)
450
 
                    raise HistoryMissing(self.branch, 'revision', parent_id)
451
 
                else:
452
 
                    mutter("commit will ghost revision %r", parent_id)
 
460
                    raise BzrCheckError("branch %s is missing revision {%s}"
 
461
                            % (self.branch, parent_id))
453
462
            
454
 
    def _make_revision(self):
455
 
        """Record a new revision object for this commit."""
456
 
        rev = Revision(timestamp=self.timestamp,
457
 
                       timezone=self.timezone,
458
 
                       committer=self.committer,
459
 
                       message=self.message,
460
 
                       inventory_sha1=self.inv_sha1,
461
 
                       revision_id=self.rev_id,
462
 
                       properties=self.revprops)
463
 
        rev.parent_ids = self.parents
464
 
        self.branch.repository.add_revision(self.rev_id, rev, self.new_inv, self.config)
465
 
 
466
463
    def _remove_deleted(self):
467
464
        """Remove deleted files from the working inventories.
468
465
 
488
485
                del self.work_inv[file_id]
489
486
            self.work_tree._write_inventory(self.work_inv)
490
487
 
491
 
    def _store_snapshot(self):
492
 
        """Pass over inventory and record a snapshot.
493
 
 
494
 
        Entries get a new revision when they are modified in 
495
 
        any way, which includes a merge with a new set of
496
 
        parents that have the same entry. 
497
 
        """
498
 
        # XXX: Need to think more here about when the user has
499
 
        # made a specific decision on a particular value -- c.f.
500
 
        # mark-merge.  
501
 
        for path, ie in self.new_inv.iter_entries():
502
 
            previous_entries = ie.find_previous_heads(
503
 
                self.parent_invs,
504
 
                self.weave_store,
505
 
                self.branch.repository.get_transaction())
506
 
            if ie.revision is None:
507
 
                change = ie.snapshot(self.rev_id, path, previous_entries,
508
 
                                     self.work_tree, self.weave_store,
509
 
                                     self.branch.get_transaction())
510
 
            else:
511
 
                change = "unchanged"
512
 
            self.reporter.snapshot_change(change, path)
513
 
 
514
488
    def _populate_new_inv(self):
515
489
        """Build revision inventory.
516
490
 
521
495
        None; inventory entries that are carried over untouched have their
522
496
        revision set to their prior value.
523
497
        """
 
498
        # ESEPARATIONOFCONCERNS: this function is diffing and using the diff
 
499
        # results to create a new inventory at the same time, which results
 
500
        # in bugs like #46635.  Any reason not to use/enhance Tree.changes_from?
 
501
        # ADHB 11-07-2006
524
502
        mutter("Selecting files for commit with filter %s", self.specific_files)
525
 
        self.new_inv = Inventory(revision_id=self.rev_id)
526
 
        for path, new_ie in self.work_inv.iter_entries():
 
503
        # at this point we dont copy the root entry:
 
504
        entries = self.work_inv.iter_entries()
 
505
        entries.next()
 
506
        self._emit_progress_update()
 
507
        for path, new_ie in entries:
 
508
            self._emit_progress_update()
527
509
            file_id = new_ie.file_id
528
 
            mutter('check %s {%s}', path, new_ie.file_id)
529
 
            if self.specific_files:
530
 
                if not is_inside_any(self.specific_files, path):
531
 
                    mutter('%s not selected for commit', path)
532
 
                    self._carry_entry(file_id)
 
510
            # mutter('check %s {%s}', path, file_id)
 
511
            if (not self.specific_files or 
 
512
                is_inside_or_parent_of_any(self.specific_files, path)):
 
513
                    # mutter('%s selected for commit', path)
 
514
                    ie = new_ie.copy()
 
515
                    ie.revision = None
 
516
            else:
 
517
                # mutter('%s not selected for commit', path)
 
518
                if self.basis_inv.has_id(file_id):
 
519
                    ie = self.basis_inv[file_id].copy()
 
520
                else:
 
521
                    # this entry is new and not being committed
533
522
                    continue
534
 
                else:
535
 
                    # this is selected, ensure its parents are too.
536
 
                    parent_id = new_ie.parent_id
537
 
                    while parent_id != ROOT_ID:
538
 
                        if not self.new_inv.has_id(parent_id):
539
 
                            ie = self._select_entry(self.work_inv[parent_id])
540
 
                            mutter('%s selected for commit because of %s',
541
 
                                   self.new_inv.id2path(parent_id), path)
542
 
 
543
 
                        ie = self.new_inv[parent_id]
544
 
                        if ie.revision is not None:
545
 
                            ie.revision = None
546
 
                            mutter('%s selected for commit because of %s',
547
 
                                   self.new_inv.id2path(parent_id), path)
548
 
                        parent_id = ie.parent_id
549
 
            mutter('%s selected for commit', path)
550
 
            self._select_entry(new_ie)
551
 
 
552
 
    def _select_entry(self, new_ie):
553
 
        """Make new_ie be considered for committing."""
554
 
        ie = new_ie.copy()
555
 
        ie.revision = None
556
 
        self.new_inv.add(ie)
557
 
        return ie
558
 
 
559
 
    def _carry_entry(self, file_id):
560
 
        """Carry the file unchanged from the basis revision."""
561
 
        if self.basis_inv.has_id(file_id):
562
 
            self.new_inv.add(self.basis_inv[file_id].copy())
 
523
 
 
524
            self.builder.record_entry_contents(ie, self.parent_invs, 
 
525
                path, self.work_tree)
 
526
            # describe the nature of the change that has occurred relative to
 
527
            # the basis inventory.
 
528
            if (self.basis_inv.has_id(ie.file_id)):
 
529
                basis_ie = self.basis_inv[ie.file_id]
 
530
            else:
 
531
                basis_ie = None
 
532
            change = ie.describe_change(basis_ie, ie)
 
533
            if change in (InventoryEntry.RENAMED, 
 
534
                InventoryEntry.MODIFIED_AND_RENAMED):
 
535
                old_path = self.basis_inv.id2path(ie.file_id)
 
536
                self.reporter.renamed(change, old_path, path)
 
537
            else:
 
538
                self.reporter.snapshot_change(change, path)
 
539
 
 
540
        if not self.specific_files:
 
541
            return
 
542
 
 
543
        # ignore removals that don't match filespec
 
544
        for path, new_ie in self.basis_inv.iter_entries():
 
545
            if new_ie.file_id in self.work_inv:
 
546
                continue
 
547
            if is_inside_any(self.specific_files, path):
 
548
                continue
 
549
            ie = new_ie.copy()
 
550
            ie.revision = None
 
551
            self.builder.record_entry_contents(ie, self.parent_invs, path,
 
552
                                               self.basis_tree)
 
553
 
 
554
    def _emit_progress_update(self):
 
555
        """Emit an update to the progress bar."""
 
556
        self.pb.update("Committing", self.pb_count, self.pb_total)
 
557
        self.pb_count += 1
563
558
 
564
559
    def _report_deletes(self):
565
 
        for file_id in self.basis_inv:
566
 
            if file_id not in self.new_inv:
567
 
                self.reporter.deleted(self.basis_inv.id2path(file_id))
568
 
 
569
 
def _gen_revision_id(config, when):
570
 
    """Return new revision-id."""
571
 
    s = '%s-%s-' % (config.user_email(), compact_date(when))
572
 
    s += hexlify(rand_bytes(8))
573
 
    return s
 
560
        for path, ie in self.basis_inv.iter_entries():
 
561
            if ie.file_id not in self.builder.new_inventory:
 
562
                self.reporter.deleted(path)
 
563
 
 
564