/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 breezy/commit.py

  • Committer: Jelmer Vernooij
  • Author(s): Richard Wilbur
  • Date: 2017-05-30 23:37:11 UTC
  • mto: This revision was merged to the branch mainline in revision 6645.
  • Revision ID: jelmer@jelmer.uk-20170530233711-r0m0qp8hpkqzpopw
Fix order in which files are processed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
from __future__ import absolute_import
17
18
 
18
19
# The newly committed revision is going to have a shape corresponding
19
20
# to that of the working tree.  Files that are not in the
49
50
# TODO: Change the parameter 'rev_id' to 'revision_id' to be consistent with
50
51
# the rest of the code; add a deprecation of the old name.
51
52
 
52
 
from bzrlib import (
 
53
from . import (
53
54
    debug,
54
55
    errors,
55
 
    revision,
56
56
    trace,
57
57
    tree,
 
58
    ui,
58
59
    )
59
 
from bzrlib.branch import Branch
60
 
from bzrlib.cleanup import OperationWithCleanups
61
 
import bzrlib.config
62
 
from bzrlib.errors import (BzrError, PointlessCommit,
63
 
                           ConflictsInTree,
64
 
                           StrictCommitFailed
65
 
                           )
66
 
from bzrlib.osutils import (get_user_encoding,
67
 
                            is_inside_any,
68
 
                            minimum_path_selection,
69
 
                            splitpath,
70
 
                            )
71
 
from bzrlib.trace import mutter, note, is_quiet
72
 
from bzrlib.inventory import Inventory, InventoryEntry, make_entry
73
 
from bzrlib import symbol_versioning
74
 
from bzrlib.urlutils import unescape_for_display
75
 
import bzrlib.ui
 
60
from .branch import Branch
 
61
from .cleanup import OperationWithCleanups
 
62
import breezy.config
 
63
from .errors import (BzrError, PointlessCommit,
 
64
                     ConflictsInTree,
 
65
                     StrictCommitFailed
 
66
                     )
 
67
from .osutils import (get_user_encoding,
 
68
                      is_inside_any,
 
69
                      minimum_path_selection,
 
70
                      splitpath,
 
71
                      )
 
72
from .trace import mutter, note, is_quiet
 
73
from .inventory import Inventory, InventoryEntry, make_entry
 
74
from .urlutils import unescape_for_display
 
75
from .i18n import gettext
76
76
 
77
77
 
78
78
class NullCommitReporter(object):
79
79
    """I report on progress of a commit."""
80
80
 
81
 
    def started(self, revno, revid, location=None):
82
 
        if location is None:
83
 
            symbol_versioning.warn("As of bzr 1.0 you must pass a location "
84
 
                                   "to started.", DeprecationWarning,
85
 
                                   stacklevel=2)
 
81
    def started(self, revno, revid, location):
86
82
        pass
87
83
 
88
84
    def snapshot_change(self, change, path):
114
110
        note(format, *args)
115
111
 
116
112
    def snapshot_change(self, change, path):
117
 
        if path == '' and change in ('added', 'modified'):
 
113
        if path == '' and change in (gettext('added'), gettext('modified')):
118
114
            return
119
115
        self._note("%s %s", change, path)
120
116
 
121
 
    def started(self, revno, rev_id, location=None):
122
 
        if location is not None:
123
 
            location = ' to: ' + unescape_for_display(location, 'utf-8')
124
 
        else:
125
 
            # When started was added, location was only made optional by
126
 
            # accident.  Matt Nordhoff 20071129
127
 
            symbol_versioning.warn("As of bzr 1.0 you must pass a location "
128
 
                                   "to started.", DeprecationWarning,
129
 
                                   stacklevel=2)
130
 
            location = ''
131
 
        self._note('Committing%s', location)
 
117
    def started(self, revno, rev_id, location):
 
118
        self._note(
 
119
            gettext('Committing to: %s'),
 
120
            unescape_for_display(location, 'utf-8'))
132
121
 
133
122
    def completed(self, revno, rev_id):
134
 
        self._note('Committed revision %d.', revno)
 
123
        self._note(gettext('Committed revision %d.'), revno)
135
124
        # self._note goes to the console too; so while we want to log the
136
125
        # rev_id, we can't trivially only log it. (See bug 526425). Long
137
126
        # term we should rearrange the reporting structure, but for now
140
129
        mutter('Committed revid %s as revno %d.', rev_id, revno)
141
130
 
142
131
    def deleted(self, path):
143
 
        self._note('deleted %s', path)
 
132
        self._note(gettext('deleted %s'), path)
144
133
 
145
134
    def missing(self, path):
146
 
        self._note('missing %s', path)
 
135
        self._note(gettext('missing %s'), path)
147
136
 
148
137
    def renamed(self, change, old_path, new_path):
149
138
        self._note('%s %s => %s', change, old_path, new_path)
166
155
    """
167
156
    def __init__(self,
168
157
                 reporter=None,
169
 
                 config=None):
 
158
                 config_stack=None):
170
159
        """Create a Commit object.
171
160
 
172
161
        :param reporter: the default reporter to use or None to decide later
173
162
        """
174
163
        self.reporter = reporter
175
 
        self.config = config
 
164
        self.config_stack = config_stack
 
165
 
 
166
    @staticmethod
 
167
    def update_revprops(revprops, branch, authors=None,
 
168
                        local=False, possible_master_transports=None):
 
169
        if revprops is None:
 
170
            revprops = {}
 
171
        if possible_master_transports is None:
 
172
            possible_master_transports = []
 
173
        if not 'branch-nick' in revprops:
 
174
            revprops['branch-nick'] = branch._get_nick(
 
175
                local,
 
176
                possible_master_transports)
 
177
        if authors is not None:
 
178
            if 'author' in revprops or 'authors' in revprops:
 
179
                # XXX: maybe we should just accept one of them?
 
180
                raise AssertionError('author property given twice')
 
181
            if authors:
 
182
                for individual in authors:
 
183
                    if '\n' in individual:
 
184
                        raise AssertionError('\\n is not a valid character '
 
185
                                'in an author identity')
 
186
                revprops['authors'] = '\n'.join(authors)
 
187
        return revprops
176
188
 
177
189
    def commit(self,
178
190
               message=None,
192
204
               message_callback=None,
193
205
               recursive='down',
194
206
               exclude=None,
195
 
               possible_master_transports=None):
 
207
               possible_master_transports=None,
 
208
               lossy=False):
196
209
        """Commit working copy as a new revision.
197
210
 
198
211
        :param message: the commit message (it or message_callback is required)
225
238
        :param exclude: None or a list of relative paths to exclude from the
226
239
            commit. Pending changes to excluded files will be ignored by the
227
240
            commit.
 
241
        :param lossy: When committing to a foreign VCS, ignore any
 
242
            data that can not be natively represented.
228
243
        """
229
244
        operation = OperationWithCleanups(self._commit)
230
245
        self.revprops = revprops or {}
231
246
        # XXX: Can be set on __init__ or passed in - this is a bit ugly.
232
 
        self.config = config or self.config
 
247
        self.config_stack = config or self.config_stack
233
248
        return operation.run(
234
249
               message=message,
235
250
               timestamp=timestamp,
246
261
               message_callback=message_callback,
247
262
               recursive=recursive,
248
263
               exclude=exclude,
249
 
               possible_master_transports=possible_master_transports)
 
264
               possible_master_transports=possible_master_transports,
 
265
               lossy=lossy)
250
266
 
251
267
    def _commit(self, operation, message, timestamp, timezone, committer,
252
268
            specific_files, rev_id, allow_pointless, strict, verbose,
253
269
            working_tree, local, reporter, message_callback, recursive,
254
 
            exclude, possible_master_transports):
 
270
            exclude, possible_master_transports, lossy):
255
271
        mutter('preparing to commit')
256
272
 
257
273
        if working_tree is None:
289
305
                minimum_path_selection(specific_files))
290
306
        else:
291
307
            self.specific_files = None
292
 
            
 
308
 
293
309
        self.allow_pointless = allow_pointless
294
310
        self.message_callback = message_callback
295
311
        self.timestamp = timestamp
309
325
            not self.branch.repository._format.supports_tree_reference and
310
326
            (self.branch.repository._format.fast_deltas or
311
327
             len(self.parents) < 2))
312
 
        self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
328
        self.pb = ui.ui_factory.nested_progress_bar()
313
329
        operation.add_cleanup(self.pb.finished)
314
330
        self.basis_revid = self.work_tree.last_revision()
315
331
        self.basis_tree = self.work_tree.basis_tree()
323
339
        self._check_bound_branch(operation, possible_master_transports)
324
340
 
325
341
        # Check that the working tree is up to date
326
 
        old_revno, new_revno = self._check_out_of_date_tree()
 
342
        old_revno, old_revid, new_revno = self._check_out_of_date_tree()
327
343
 
328
344
        # Complete configuration setup
329
345
        if reporter is not None:
330
346
            self.reporter = reporter
331
347
        elif self.reporter is None:
332
348
            self.reporter = self._select_reporter()
333
 
        if self.config is None:
334
 
            self.config = self.branch.get_config()
 
349
        if self.config_stack is None:
 
350
            self.config_stack = self.work_tree.get_config_stack()
335
351
 
336
352
        self._set_specific_file_ids()
337
353
 
343
359
        self.pb_stage_count = 0
344
360
        self.pb_stage_total = 5
345
361
        if self.bound_branch:
346
 
            self.pb_stage_total += 1
 
362
            # 2 extra stages: "Uploading data to master branch" and "Merging
 
363
            # tags to master branch"
 
364
            self.pb_stage_total += 2
347
365
        self.pb.show_pct = False
348
366
        self.pb.show_spinner = False
349
367
        self.pb.show_eta = False
361
379
 
362
380
        # Collect the changes
363
381
        self._set_progress_stage("Collecting changes", counter=True)
 
382
        self._lossy = lossy
364
383
        self.builder = self.branch.get_commit_builder(self.parents,
365
 
            self.config, timestamp, timezone, committer, self.revprops, rev_id)
 
384
            self.config_stack, timestamp, timezone, committer, self.revprops,
 
385
            rev_id, lossy=lossy)
 
386
        if not self.builder.supports_record_entry_contents and self.exclude:
 
387
            self.builder.abort()
 
388
            raise errors.ExcludesUnsupported(self.branch.repository)
 
389
 
 
390
        if self.builder.updates_branch and self.bound_branch:
 
391
            self.builder.abort()
 
392
            raise AssertionError(
 
393
                "bound branches not supported for commit builders "
 
394
                "that update the branch")
366
395
 
367
396
        try:
368
397
            self.builder.will_record_deletes()
392
421
            # Add revision data to the local branch
393
422
            self.rev_id = self.builder.commit(self.message)
394
423
 
395
 
        except Exception, e:
 
424
        except Exception as e:
396
425
            mutter("aborting commit write group because of exception:")
397
426
            trace.log_exception_quietly()
398
 
            note("aborting commit write group: %r" % (e,))
399
427
            self.builder.abort()
400
428
            raise
401
429
 
402
 
        self._process_pre_hooks(old_revno, new_revno)
403
 
 
404
 
        # Upload revision data to the master.
405
 
        # this will propagate merged revisions too if needed.
406
 
        if self.bound_branch:
407
 
            self._set_progress_stage("Uploading data to master branch")
408
 
            # 'commit' to the master first so a timeout here causes the
409
 
            # local branch to be out of date
410
 
            self.master_branch.import_last_revision_info(
411
 
                self.branch.repository, new_revno, self.rev_id)
412
 
 
413
 
        # and now do the commit locally.
414
 
        self.branch.set_last_revision_info(new_revno, self.rev_id)
 
430
        self._update_branches(old_revno, old_revid, new_revno)
415
431
 
416
432
        # Make the working tree be up to date with the branch. This
417
433
        # includes automatic changes scheduled to be made to the tree, such
424
440
        self._process_post_hooks(old_revno, new_revno)
425
441
        return self.rev_id
426
442
 
 
443
    def _update_branches(self, old_revno, old_revid, new_revno):
 
444
        """Update the master and local branch to the new revision.
 
445
 
 
446
        This will try to make sure that the master branch is updated
 
447
        before the local branch.
 
448
 
 
449
        :param old_revno: Revision number of master branch before the
 
450
            commit
 
451
        :param old_revid: Tip of master branch before the commit
 
452
        :param new_revno: Revision number of the new commit
 
453
        """
 
454
        if not self.builder.updates_branch:
 
455
            self._process_pre_hooks(old_revno, new_revno)
 
456
 
 
457
            # Upload revision data to the master.
 
458
            # this will propagate merged revisions too if needed.
 
459
            if self.bound_branch:
 
460
                self._set_progress_stage("Uploading data to master branch")
 
461
                # 'commit' to the master first so a timeout here causes the
 
462
                # local branch to be out of date
 
463
                (new_revno, self.rev_id) = self.master_branch.import_last_revision_info_and_tags(
 
464
                    self.branch, new_revno, self.rev_id, lossy=self._lossy)
 
465
                if self._lossy:
 
466
                    self.branch.fetch(self.master_branch, self.rev_id)
 
467
 
 
468
            # and now do the commit locally.
 
469
            self.branch.set_last_revision_info(new_revno, self.rev_id)
 
470
        else:
 
471
            try:
 
472
                self._process_pre_hooks(old_revno, new_revno)
 
473
            except:
 
474
                # The commit builder will already have updated the branch,
 
475
                # revert it.
 
476
                self.branch.set_last_revision_info(old_revno, old_revid)
 
477
                raise
 
478
 
 
479
        # Merge local tags to remote
 
480
        if self.bound_branch:
 
481
            self._set_progress_stage("Merging tags to master branch")
 
482
            tag_updates, tag_conflicts = self.branch.tags.merge_to(
 
483
                self.master_branch.tags)
 
484
            if tag_conflicts:
 
485
                warning_lines = ['    ' + name for name, _, _ in tag_conflicts]
 
486
                note( gettext("Conflicting tags in bound branch:\n{0}".format(
 
487
                    "\n".join(warning_lines))) )
 
488
 
427
489
    def _select_reporter(self):
428
490
        """Select the CommitReporter to use."""
429
491
        if is_quiet():
436
498
        # A merge with no effect on files
437
499
        if len(self.parents) > 1:
438
500
            return
439
 
        # TODO: we could simplify this by using self.builder.basis_delta.
440
 
 
441
 
        # The initial commit adds a root directory, but this in itself is not
442
 
        # a worthwhile commit.
443
 
        if (self.basis_revid == revision.NULL_REVISION and
444
 
            ((self.builder.new_inventory is not None and
445
 
             len(self.builder.new_inventory) == 1) or
446
 
            len(self.builder._basis_delta) == 1)):
447
 
            raise PointlessCommit()
448
501
        if self.builder.any_changes():
449
502
            return
450
503
        raise PointlessCommit()
495
548
    def _check_out_of_date_tree(self):
496
549
        """Check that the working tree is up to date.
497
550
 
498
 
        :return: old_revision_number,new_revision_number tuple
 
551
        :return: old_revision_number, old_revision_id, new_revision_number
 
552
            tuple
499
553
        """
500
554
        try:
501
555
            first_tree_parent = self.work_tree.get_parent_ids()[0]
504
558
            # this is so that we still consider the master branch
505
559
            # - in a checkout scenario the tree may have no
506
560
            # parents but the branch may do.
507
 
            first_tree_parent = bzrlib.revision.NULL_REVISION
 
561
            first_tree_parent = breezy.revision.NULL_REVISION
508
562
        old_revno, master_last = self.master_branch.last_revision_info()
509
563
        if master_last != first_tree_parent:
510
 
            if master_last != bzrlib.revision.NULL_REVISION:
 
564
            if master_last != breezy.revision.NULL_REVISION:
511
565
                raise errors.OutOfDateTree(self.work_tree)
512
566
        if self.branch.repository.has_revision(first_tree_parent):
513
567
            new_revno = old_revno + 1
514
568
        else:
515
569
            # ghost parents never appear in revision history.
516
570
            new_revno = 1
517
 
        return old_revno,new_revno
 
571
        return old_revno, master_last, new_revno
518
572
 
519
573
    def _process_pre_hooks(self, old_revno, new_revno):
520
574
        """Process any registered pre commit hooks."""
526
580
        # Process the post commit hooks, if any
527
581
        self._set_progress_stage("Running post_commit hooks")
528
582
        # old style commit hooks - should be deprecated ? (obsoleted in
529
 
        # 0.15)
530
 
        if self.config.post_commit() is not None:
531
 
            hooks = self.config.post_commit().split(' ')
 
583
        # 0.15^H^H^H^H 2.5.0)
 
584
        post_commit = self.config_stack.get('post_commit')
 
585
        if post_commit is not None:
 
586
            hooks = post_commit.split(' ')
532
587
            # this would be nicer with twisted.python.reflect.namedAny
533
588
            for hook in hooks:
534
589
                result = eval(hook + '(branch, rev_id)',
535
590
                              {'branch':self.branch,
536
 
                               'bzrlib':bzrlib,
 
591
                               'breezy':breezy,
537
592
                               'rev_id':self.rev_id})
538
593
        # process new style post commit hooks
539
594
        self._process_hooks("post_commit", old_revno, new_revno)
555
610
        if self.parents:
556
611
            old_revid = self.parents[0]
557
612
        else:
558
 
            old_revid = bzrlib.revision.NULL_REVISION
 
613
            old_revid = breezy.revision.NULL_REVISION
559
614
 
560
615
        if hook_name == "pre_commit":
561
616
            future_tree = self.builder.revision_tree()
587
642
        # entries and the order is preserved when doing this.
588
643
        if self.use_record_iter_changes:
589
644
            return
590
 
        self.basis_inv = self.basis_tree.inventory
 
645
        self.basis_inv = self.basis_tree.root_inventory
591
646
        self.parent_invs = [self.basis_inv]
592
647
        for revision in self.parents[1:]:
593
648
            if self.branch.repository.has_revision(revision):
646
701
                # Reset the new path (None) and new versioned flag (False)
647
702
                change = (change[0], (change[1][0], None), change[2],
648
703
                    (change[3][0], False)) + change[4:]
 
704
                new_path = change[1][1]
 
705
                versioned = False
649
706
            elif kind == 'tree-reference':
650
707
                if self.recursive == 'down':
651
708
                    self._commit_nested_tree(change[0], change[1][1])
655
712
                    if new_path is None:
656
713
                        reporter.deleted(old_path)
657
714
                    elif old_path is None:
658
 
                        reporter.snapshot_change('added', new_path)
 
715
                        reporter.snapshot_change(gettext('added'), new_path)
659
716
                    elif old_path != new_path:
660
 
                        reporter.renamed('renamed', old_path, new_path)
 
717
                        reporter.renamed(gettext('renamed'), old_path, new_path)
661
718
                    else:
662
719
                        if (new_path or 
663
720
                            self.work_tree.branch.repository._format.rich_root_data):
664
721
                            # Don't report on changes to '' in non rich root
665
722
                            # repositories.
666
 
                            reporter.snapshot_change('modified', new_path)
 
723
                            reporter.snapshot_change(gettext('modified'), new_path)
667
724
            self._next_progress_entry()
668
725
        # Unversion IDs that were found to be deleted
669
726
        self.deleted_ids = deleted_ids
675
732
        if self.specific_files or self.exclude:
676
733
            specific_files = self.specific_files or []
677
734
            for path, old_ie in self.basis_inv.iter_entries():
678
 
                if old_ie.file_id in self.builder.new_inventory:
 
735
                if self.builder.new_inventory.has_id(old_ie.file_id):
679
736
                    # already added - skip.
680
737
                    continue
681
738
                if (is_inside_any(specific_files, path)
710
767
            deleted_ids = set(self.basis_inv) - set(self.builder.new_inventory)
711
768
        if deleted_ids:
712
769
            self.any_entries_deleted = True
713
 
            deleted = [(self.basis_tree.id2path(file_id), file_id)
714
 
                for file_id in deleted_ids]
715
 
            deleted.sort()
 
770
            deleted = sorted([(self.basis_tree.id2path(file_id), file_id)
 
771
                for file_id in deleted_ids])
716
772
            # XXX: this is not quite directory-order sorting
717
773
            for path, file_id in deleted:
718
774
                self.builder.record_delete(path, file_id)
752
808
        deleted_paths = {}
753
809
        # XXX: Note that entries may have the wrong kind because the entry does
754
810
        # not reflect the status on disk.
755
 
        work_inv = self.work_tree.inventory
756
811
        # NB: entries will include entries within the excluded ids/paths
757
812
        # because iter_entries_by_dir has no 'exclude' facility today.
758
 
        entries = work_inv.iter_entries_by_dir(
 
813
        entries = self.work_tree.iter_entries_by_dir(
759
814
            specific_file_ids=self.specific_file_ids, yield_parents=True)
760
815
        for path, existing_ie in entries:
761
816
            file_id = existing_ie.file_id
892
947
            self.reporter.renamed(change, old_path, path)
893
948
            self._next_progress_entry()
894
949
        else:
895
 
            if change == 'unchanged':
 
950
            if change == gettext('unchanged'):
896
951
                return
897
952
            self.reporter.snapshot_change(change, path)
898
953
            self._next_progress_entry()
914
969
 
915
970
    def _emit_progress(self):
916
971
        if self.pb_entries_count is not None:
917
 
            text = "%s [%d] - Stage" % (self.pb_stage_name,
 
972
            text = gettext("{0} [{1}] - Stage").format(self.pb_stage_name,
918
973
                self.pb_entries_count)
919
974
        else:
920
 
            text = "%s - Stage" % (self.pb_stage_name, )
 
975
            text = gettext("%s - Stage") % (self.pb_stage_name, )
921
976
        self.pb.update(text, self.pb_stage_count, self.pb_stage_total)
922
977
 
923
978
    def _set_specific_file_ids(self):