/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: Martin
  • Date: 2017-06-11 01:12:29 UTC
  • mto: This revision was merged to the branch mainline in revision 6685.
  • Revision ID: gzlist@googlemail.com-20170611011229-somdjbalby8m7vlw
Make _chunks_to_lines pass for Python 3

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
176
165
 
177
166
    @staticmethod
178
 
    def update_revprops(revprops, branch, authors=None, author=None,
 
167
    def update_revprops(revprops, branch, authors=None,
179
168
                        local=False, possible_master_transports=None):
180
169
        if revprops is None:
181
170
            revprops = {}
186
175
                local,
187
176
                possible_master_transports)
188
177
        if authors is not None:
189
 
            if author is not None:
190
 
                raise AssertionError('Specifying both author and authors '
191
 
                        'is not allowed. Specify just authors instead')
192
178
            if 'author' in revprops or 'authors' in revprops:
193
179
                # XXX: maybe we should just accept one of them?
194
180
                raise AssertionError('author property given twice')
198
184
                        raise AssertionError('\\n is not a valid character '
199
185
                                'in an author identity')
200
186
                revprops['authors'] = '\n'.join(authors)
201
 
        if author is not None:
202
 
            symbol_versioning.warn('The parameter author was deprecated'
203
 
                   ' in version 1.13. Use authors instead',
204
 
                   DeprecationWarning)
205
 
            if 'author' in revprops or 'authors' in revprops:
206
 
                # XXX: maybe we should just accept one of them?
207
 
                raise AssertionError('author property given twice')
208
 
            if '\n' in author:
209
 
                raise AssertionError('\\n is not a valid character '
210
 
                        'in an author identity')
211
 
            revprops['authors'] = author
212
187
        return revprops
213
188
 
214
189
    def commit(self,
229
204
               message_callback=None,
230
205
               recursive='down',
231
206
               exclude=None,
232
 
               possible_master_transports=None):
 
207
               possible_master_transports=None,
 
208
               lossy=False):
233
209
        """Commit working copy as a new revision.
234
210
 
235
211
        :param message: the commit message (it or message_callback is required)
262
238
        :param exclude: None or a list of relative paths to exclude from the
263
239
            commit. Pending changes to excluded files will be ignored by the
264
240
            commit.
 
241
        :param lossy: When committing to a foreign VCS, ignore any
 
242
            data that can not be natively represented.
265
243
        """
266
244
        operation = OperationWithCleanups(self._commit)
267
245
        self.revprops = revprops or {}
268
246
        # XXX: Can be set on __init__ or passed in - this is a bit ugly.
269
 
        self.config = config or self.config
 
247
        self.config_stack = config or self.config_stack
270
248
        return operation.run(
271
249
               message=message,
272
250
               timestamp=timestamp,
283
261
               message_callback=message_callback,
284
262
               recursive=recursive,
285
263
               exclude=exclude,
286
 
               possible_master_transports=possible_master_transports)
 
264
               possible_master_transports=possible_master_transports,
 
265
               lossy=lossy)
287
266
 
288
267
    def _commit(self, operation, message, timestamp, timezone, committer,
289
268
            specific_files, rev_id, allow_pointless, strict, verbose,
290
269
            working_tree, local, reporter, message_callback, recursive,
291
 
            exclude, possible_master_transports):
 
270
            exclude, possible_master_transports, lossy):
292
271
        mutter('preparing to commit')
293
272
 
294
273
        if working_tree is None:
326
305
                minimum_path_selection(specific_files))
327
306
        else:
328
307
            self.specific_files = None
329
 
            
 
308
 
330
309
        self.allow_pointless = allow_pointless
331
310
        self.message_callback = message_callback
332
311
        self.timestamp = timestamp
346
325
            not self.branch.repository._format.supports_tree_reference and
347
326
            (self.branch.repository._format.fast_deltas or
348
327
             len(self.parents) < 2))
349
 
        self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
328
        self.pb = ui.ui_factory.nested_progress_bar()
350
329
        operation.add_cleanup(self.pb.finished)
351
330
        self.basis_revid = self.work_tree.last_revision()
352
331
        self.basis_tree = self.work_tree.basis_tree()
360
339
        self._check_bound_branch(operation, possible_master_transports)
361
340
 
362
341
        # Check that the working tree is up to date
363
 
        old_revno, new_revno = self._check_out_of_date_tree()
 
342
        old_revno, old_revid, new_revno = self._check_out_of_date_tree()
364
343
 
365
344
        # Complete configuration setup
366
345
        if reporter is not None:
367
346
            self.reporter = reporter
368
347
        elif self.reporter is None:
369
348
            self.reporter = self._select_reporter()
370
 
        if self.config is None:
371
 
            self.config = self.branch.get_config()
 
349
        if self.config_stack is None:
 
350
            self.config_stack = self.work_tree.get_config_stack()
372
351
 
373
352
        self._set_specific_file_ids()
374
353
 
380
359
        self.pb_stage_count = 0
381
360
        self.pb_stage_total = 5
382
361
        if self.bound_branch:
383
 
            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
384
365
        self.pb.show_pct = False
385
366
        self.pb.show_spinner = False
386
367
        self.pb.show_eta = False
398
379
 
399
380
        # Collect the changes
400
381
        self._set_progress_stage("Collecting changes", counter=True)
 
382
        self._lossy = lossy
401
383
        self.builder = self.branch.get_commit_builder(self.parents,
402
 
            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")
403
395
 
404
396
        try:
405
397
            self.builder.will_record_deletes()
429
421
            # Add revision data to the local branch
430
422
            self.rev_id = self.builder.commit(self.message)
431
423
 
432
 
        except Exception, e:
 
424
        except Exception as e:
433
425
            mutter("aborting commit write group because of exception:")
434
426
            trace.log_exception_quietly()
435
 
            note("aborting commit write group: %r" % (e,))
436
427
            self.builder.abort()
437
428
            raise
438
429
 
439
 
        self._process_pre_hooks(old_revno, new_revno)
440
 
 
441
 
        # Upload revision data to the master.
442
 
        # this will propagate merged revisions too if needed.
443
 
        if self.bound_branch:
444
 
            self._set_progress_stage("Uploading data to master branch")
445
 
            # 'commit' to the master first so a timeout here causes the
446
 
            # local branch to be out of date
447
 
            self.master_branch.import_last_revision_info(
448
 
                self.branch.repository, new_revno, self.rev_id)
449
 
 
450
 
        # and now do the commit locally.
451
 
        self.branch.set_last_revision_info(new_revno, self.rev_id)
 
430
        self._update_branches(old_revno, old_revid, new_revno)
452
431
 
453
432
        # Make the working tree be up to date with the branch. This
454
433
        # includes automatic changes scheduled to be made to the tree, such
461
440
        self._process_post_hooks(old_revno, new_revno)
462
441
        return self.rev_id
463
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
 
464
489
    def _select_reporter(self):
465
490
        """Select the CommitReporter to use."""
466
491
        if is_quiet():
473
498
        # A merge with no effect on files
474
499
        if len(self.parents) > 1:
475
500
            return
476
 
        # TODO: we could simplify this by using self.builder.basis_delta.
477
 
 
478
 
        # The initial commit adds a root directory, but this in itself is not
479
 
        # a worthwhile commit.
480
 
        if (self.basis_revid == revision.NULL_REVISION and
481
 
            ((self.builder.new_inventory is not None and
482
 
             len(self.builder.new_inventory) == 1) or
483
 
            len(self.builder._basis_delta) == 1)):
484
 
            raise PointlessCommit()
485
501
        if self.builder.any_changes():
486
502
            return
487
503
        raise PointlessCommit()
532
548
    def _check_out_of_date_tree(self):
533
549
        """Check that the working tree is up to date.
534
550
 
535
 
        :return: old_revision_number,new_revision_number tuple
 
551
        :return: old_revision_number, old_revision_id, new_revision_number
 
552
            tuple
536
553
        """
537
554
        try:
538
555
            first_tree_parent = self.work_tree.get_parent_ids()[0]
541
558
            # this is so that we still consider the master branch
542
559
            # - in a checkout scenario the tree may have no
543
560
            # parents but the branch may do.
544
 
            first_tree_parent = bzrlib.revision.NULL_REVISION
 
561
            first_tree_parent = breezy.revision.NULL_REVISION
545
562
        old_revno, master_last = self.master_branch.last_revision_info()
546
563
        if master_last != first_tree_parent:
547
 
            if master_last != bzrlib.revision.NULL_REVISION:
 
564
            if master_last != breezy.revision.NULL_REVISION:
548
565
                raise errors.OutOfDateTree(self.work_tree)
549
566
        if self.branch.repository.has_revision(first_tree_parent):
550
567
            new_revno = old_revno + 1
551
568
        else:
552
569
            # ghost parents never appear in revision history.
553
570
            new_revno = 1
554
 
        return old_revno,new_revno
 
571
        return old_revno, master_last, new_revno
555
572
 
556
573
    def _process_pre_hooks(self, old_revno, new_revno):
557
574
        """Process any registered pre commit hooks."""
563
580
        # Process the post commit hooks, if any
564
581
        self._set_progress_stage("Running post_commit hooks")
565
582
        # old style commit hooks - should be deprecated ? (obsoleted in
566
 
        # 0.15)
567
 
        if self.config.post_commit() is not None:
568
 
            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(' ')
569
587
            # this would be nicer with twisted.python.reflect.namedAny
570
588
            for hook in hooks:
571
589
                result = eval(hook + '(branch, rev_id)',
572
590
                              {'branch':self.branch,
573
 
                               'bzrlib':bzrlib,
 
591
                               'breezy':breezy,
574
592
                               'rev_id':self.rev_id})
575
593
        # process new style post commit hooks
576
594
        self._process_hooks("post_commit", old_revno, new_revno)
592
610
        if self.parents:
593
611
            old_revid = self.parents[0]
594
612
        else:
595
 
            old_revid = bzrlib.revision.NULL_REVISION
 
613
            old_revid = breezy.revision.NULL_REVISION
596
614
 
597
615
        if hook_name == "pre_commit":
598
616
            future_tree = self.builder.revision_tree()
624
642
        # entries and the order is preserved when doing this.
625
643
        if self.use_record_iter_changes:
626
644
            return
627
 
        self.basis_inv = self.basis_tree.inventory
 
645
        self.basis_inv = self.basis_tree.root_inventory
628
646
        self.parent_invs = [self.basis_inv]
629
647
        for revision in self.parents[1:]:
630
648
            if self.branch.repository.has_revision(revision):
683
701
                # Reset the new path (None) and new versioned flag (False)
684
702
                change = (change[0], (change[1][0], None), change[2],
685
703
                    (change[3][0], False)) + change[4:]
 
704
                new_path = change[1][1]
 
705
                versioned = False
686
706
            elif kind == 'tree-reference':
687
707
                if self.recursive == 'down':
688
708
                    self._commit_nested_tree(change[0], change[1][1])
692
712
                    if new_path is None:
693
713
                        reporter.deleted(old_path)
694
714
                    elif old_path is None:
695
 
                        reporter.snapshot_change('added', new_path)
 
715
                        reporter.snapshot_change(gettext('added'), new_path)
696
716
                    elif old_path != new_path:
697
 
                        reporter.renamed('renamed', old_path, new_path)
 
717
                        reporter.renamed(gettext('renamed'), old_path, new_path)
698
718
                    else:
699
719
                        if (new_path or 
700
720
                            self.work_tree.branch.repository._format.rich_root_data):
701
721
                            # Don't report on changes to '' in non rich root
702
722
                            # repositories.
703
 
                            reporter.snapshot_change('modified', new_path)
 
723
                            reporter.snapshot_change(gettext('modified'), new_path)
704
724
            self._next_progress_entry()
705
725
        # Unversion IDs that were found to be deleted
706
726
        self.deleted_ids = deleted_ids
712
732
        if self.specific_files or self.exclude:
713
733
            specific_files = self.specific_files or []
714
734
            for path, old_ie in self.basis_inv.iter_entries():
715
 
                if old_ie.file_id in self.builder.new_inventory:
 
735
                if self.builder.new_inventory.has_id(old_ie.file_id):
716
736
                    # already added - skip.
717
737
                    continue
718
738
                if (is_inside_any(specific_files, path)
747
767
            deleted_ids = set(self.basis_inv) - set(self.builder.new_inventory)
748
768
        if deleted_ids:
749
769
            self.any_entries_deleted = True
750
 
            deleted = [(self.basis_tree.id2path(file_id), file_id)
751
 
                for file_id in deleted_ids]
752
 
            deleted.sort()
 
770
            deleted = sorted([(self.basis_tree.id2path(file_id), file_id)
 
771
                for file_id in deleted_ids])
753
772
            # XXX: this is not quite directory-order sorting
754
773
            for path, file_id in deleted:
755
774
                self.builder.record_delete(path, file_id)
789
808
        deleted_paths = {}
790
809
        # XXX: Note that entries may have the wrong kind because the entry does
791
810
        # not reflect the status on disk.
792
 
        work_inv = self.work_tree.inventory
793
811
        # NB: entries will include entries within the excluded ids/paths
794
812
        # because iter_entries_by_dir has no 'exclude' facility today.
795
 
        entries = work_inv.iter_entries_by_dir(
 
813
        entries = self.work_tree.iter_entries_by_dir(
796
814
            specific_file_ids=self.specific_file_ids, yield_parents=True)
797
815
        for path, existing_ie in entries:
798
816
            file_id = existing_ie.file_id
929
947
            self.reporter.renamed(change, old_path, path)
930
948
            self._next_progress_entry()
931
949
        else:
932
 
            if change == 'unchanged':
 
950
            if change == gettext('unchanged'):
933
951
                return
934
952
            self.reporter.snapshot_change(change, path)
935
953
            self._next_progress_entry()
951
969
 
952
970
    def _emit_progress(self):
953
971
        if self.pb_entries_count is not None:
954
 
            text = "%s [%d] - Stage" % (self.pb_stage_name,
 
972
            text = gettext("{0} [{1}] - Stage").format(self.pb_stage_name,
955
973
                self.pb_entries_count)
956
974
        else:
957
 
            text = "%s - Stage" % (self.pb_stage_name, )
 
975
            text = gettext("%s - Stage") % (self.pb_stage_name, )
958
976
        self.pb.update(text, self.pb_stage_count, self.pb_stage_total)
959
977
 
960
978
    def _set_specific_file_ids(self):