/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
  • Date: 2017-06-08 23:30:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170608233031-3qavls2o7a1pqllj
Update imports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/commit.py
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
 
18
 
17
19
# The newly committed revision is going to have a shape corresponding
18
20
# to that of the working tree.  Files that are not in the
19
21
# working tree and that were in the predecessor are reported as
52
54
    debug,
53
55
    errors,
54
56
    trace,
 
57
    tree,
55
58
    ui,
56
59
    )
57
60
from .branch import Branch
58
 
from contextlib import ExitStack
 
61
from .cleanup import OperationWithCleanups
59
62
import breezy.config
60
 
from .errors import (BzrError,
 
63
from .errors import (BzrError, PointlessCommit,
61
64
                     ConflictsInTree,
62
65
                     StrictCommitFailed
63
66
                     )
64
67
from .osutils import (get_user_encoding,
65
 
                      has_symlinks,
66
68
                      is_inside_any,
67
69
                      minimum_path_selection,
 
70
                      splitpath,
68
71
                      )
69
72
from .trace import mutter, note, is_quiet
70
 
from .tree import TreeChange
 
73
from .bzr.inventory import Inventory, InventoryEntry, make_entry
71
74
from .urlutils import unescape_for_display
72
75
from .i18n import gettext
73
76
 
74
77
 
75
 
class PointlessCommit(BzrError):
76
 
 
77
 
    _fmt = "No changes to commit"
78
 
 
79
 
 
80
 
class CannotCommitSelectedFileMerge(BzrError):
81
 
 
82
 
    _fmt = 'Selected-file commit of merges is not supported yet:'\
83
 
        ' files %(files_str)s'
84
 
 
85
 
    def __init__(self, files):
86
 
        files_str = ', '.join(files)
87
 
        BzrError.__init__(self, files=files, files_str=files_str)
88
 
 
89
 
 
90
 
def filter_excluded(iter_changes, exclude):
91
 
    """Filter exclude filenames.
92
 
 
93
 
    :param iter_changes: iter_changes function
94
 
    :param exclude: List of paths to exclude
95
 
    :return: iter_changes function
96
 
    """
97
 
    for change in iter_changes:
98
 
        new_excluded = (change.path[1] is not None and
99
 
                        is_inside_any(exclude, change.path[1]))
100
 
 
101
 
        old_excluded = (change.path[0] is not None and
102
 
                        is_inside_any(exclude, change.path[0]))
103
 
 
104
 
        if old_excluded and new_excluded:
105
 
            continue
106
 
 
107
 
        if old_excluded or new_excluded:
108
 
            # TODO(jelmer): Perhaps raise an error here instead?
109
 
            continue
110
 
 
111
 
        yield change
112
 
 
113
 
 
114
78
class NullCommitReporter(object):
115
79
    """I report on progress of a commit."""
116
80
 
156
120
            unescape_for_display(location, 'utf-8'))
157
121
 
158
122
    def completed(self, revno, rev_id):
159
 
        if revno is not None:
160
 
            self._note(gettext('Committed revision %d.'), revno)
161
 
            # self._note goes to the console too; so while we want to log the
162
 
            # rev_id, we can't trivially only log it. (See bug 526425). Long
163
 
            # term we should rearrange the reporting structure, but for now
164
 
            # we just mutter seperately. We mutter the revid and revno together
165
 
            # so that concurrent bzr invocations won't lead to confusion.
166
 
            mutter('Committed revid %s as revno %d.', rev_id, revno)
167
 
        else:
168
 
            self._note(gettext('Committed revid %s.'), rev_id)
 
123
        self._note(gettext('Committed revision %d.'), revno)
 
124
        # self._note goes to the console too; so while we want to log the
 
125
        # rev_id, we can't trivially only log it. (See bug 526425). Long
 
126
        # term we should rearrange the reporting structure, but for now
 
127
        # we just mutter seperately. We mutter the revid and revno together
 
128
        # so that concurrent bzr invocations won't lead to confusion.
 
129
        mutter('Committed revid %s as revno %d.', rev_id, revno)
169
130
 
170
131
    def deleted(self, path):
171
132
        self._note(gettext('deleted %s'), path)
192
153
            the working directory; these should be removed from the
193
154
            working inventory.
194
155
    """
195
 
 
196
156
    def __init__(self,
197
157
                 reporter=None,
198
158
                 config_stack=None):
210
170
            revprops = {}
211
171
        if possible_master_transports is None:
212
172
            possible_master_transports = []
213
 
        if (u'branch-nick' not in revprops and
214
 
                branch.repository._format.supports_storing_branch_nick):
215
 
            revprops[u'branch-nick'] = branch._get_nick(
 
173
        if not 'branch-nick' in revprops:
 
174
            revprops['branch-nick'] = branch._get_nick(
216
175
                local,
217
176
                possible_master_transports)
218
177
        if authors is not None:
219
 
            if u'author' in revprops or u'authors' in revprops:
 
178
            if 'author' in revprops or 'authors' in revprops:
220
179
                # XXX: maybe we should just accept one of them?
221
180
                raise AssertionError('author property given twice')
222
181
            if authors:
223
182
                for individual in authors:
224
183
                    if '\n' in individual:
225
184
                        raise AssertionError('\\n is not a valid character '
226
 
                                             'in an author identity')
227
 
                revprops[u'authors'] = '\n'.join(authors)
 
185
                                'in an author identity')
 
186
                revprops['authors'] = '\n'.join(authors)
228
187
        return revprops
229
188
 
230
189
    def commit(self,
250
209
        """Commit working copy as a new revision.
251
210
 
252
211
        :param message: the commit message (it or message_callback is required)
253
 
        :param message_callback: A callback: message =
254
 
            message_callback(cmt_obj)
 
212
        :param message_callback: A callback: message = message_callback(cmt_obj)
255
213
 
256
214
        :param timestamp: if not None, seconds-since-epoch for a
257
215
            postdated/predated commit.
283
241
        :param lossy: When committing to a foreign VCS, ignore any
284
242
            data that can not be natively represented.
285
243
        """
286
 
        with ExitStack() as stack:
287
 
            self.revprops = revprops or {}
288
 
            # XXX: Can be set on __init__ or passed in - this is a bit ugly.
289
 
            self.config_stack = config or self.config_stack
290
 
            mutter('preparing to commit')
291
 
 
292
 
            if working_tree is None:
293
 
                raise BzrError("working_tree must be passed into commit().")
294
 
            else:
295
 
                self.work_tree = working_tree
296
 
                self.branch = self.work_tree.branch
297
 
                if getattr(self.work_tree, 'requires_rich_root', lambda: False)():
298
 
                    if not self.branch.repository.supports_rich_root():
299
 
                        raise errors.RootNotRich()
300
 
            if message_callback is None:
301
 
                if message is not None:
302
 
                    if isinstance(message, bytes):
303
 
                        message = message.decode(get_user_encoding())
304
 
 
305
 
                    def message_callback(x):
306
 
                        return message
307
 
                else:
308
 
                    raise BzrError("The message or message_callback keyword"
309
 
                                   " parameter is required for commit().")
310
 
 
311
 
            self.bound_branch = None
312
 
            self.any_entries_deleted = False
313
 
            if exclude is not None:
314
 
                self.exclude = sorted(
315
 
                    minimum_path_selection(exclude))
316
 
            else:
317
 
                self.exclude = []
318
 
            self.local = local
319
 
            self.master_branch = None
320
 
            self.recursive = recursive
321
 
            self.rev_id = None
322
 
            # self.specific_files is None to indicate no filter, or any iterable to
323
 
            # indicate a filter - [] means no files at all, as per iter_changes.
324
 
            if specific_files is not None:
325
 
                self.specific_files = sorted(
326
 
                    minimum_path_selection(specific_files))
327
 
            else:
328
 
                self.specific_files = None
329
 
 
330
 
            self.allow_pointless = allow_pointless
331
 
            self.message_callback = message_callback
332
 
            self.timestamp = timestamp
333
 
            self.timezone = timezone
334
 
            self.committer = committer
335
 
            self.strict = strict
336
 
            self.verbose = verbose
337
 
 
338
 
            stack.enter_context(self.work_tree.lock_write())
339
 
            self.parents = self.work_tree.get_parent_ids()
340
 
            self.pb = ui.ui_factory.nested_progress_bar()
341
 
            stack.callback(self.pb.finished)
342
 
            self.basis_revid = self.work_tree.last_revision()
343
 
            self.basis_tree = self.work_tree.basis_tree()
344
 
            stack.enter_context(self.basis_tree.lock_read())
345
 
            # Cannot commit with conflicts present.
346
 
            if len(self.work_tree.conflicts()) > 0:
347
 
                raise ConflictsInTree
348
 
 
349
 
            # Setup the bound branch variables as needed.
350
 
            self._check_bound_branch(stack, possible_master_transports)
351
 
            if self.config_stack is None:
352
 
                self.config_stack = self.work_tree.get_config_stack()
353
 
 
354
 
            # Check that the working tree is up to date
355
 
            old_revno, old_revid, new_revno = self._check_out_of_date_tree()
356
 
 
357
 
            # Complete configuration setup
358
 
            if reporter is not None:
359
 
                self.reporter = reporter
360
 
            elif self.reporter is None:
361
 
                self.reporter = self._select_reporter()
362
 
 
363
 
            # Setup the progress bar. As the number of files that need to be
364
 
            # committed in unknown, progress is reported as stages.
365
 
            # We keep track of entries separately though and include that
366
 
            # information in the progress bar during the relevant stages.
367
 
            self.pb_stage_name = ""
368
 
            self.pb_stage_count = 0
369
 
            self.pb_stage_total = 5
 
244
        operation = OperationWithCleanups(self._commit)
 
245
        self.revprops = revprops or {}
 
246
        # XXX: Can be set on __init__ or passed in - this is a bit ugly.
 
247
        self.config_stack = config or self.config_stack
 
248
        return operation.run(
 
249
               message=message,
 
250
               timestamp=timestamp,
 
251
               timezone=timezone,
 
252
               committer=committer,
 
253
               specific_files=specific_files,
 
254
               rev_id=rev_id,
 
255
               allow_pointless=allow_pointless,
 
256
               strict=strict,
 
257
               verbose=verbose,
 
258
               working_tree=working_tree,
 
259
               local=local,
 
260
               reporter=reporter,
 
261
               message_callback=message_callback,
 
262
               recursive=recursive,
 
263
               exclude=exclude,
 
264
               possible_master_transports=possible_master_transports,
 
265
               lossy=lossy)
 
266
 
 
267
    def _commit(self, operation, message, timestamp, timezone, committer,
 
268
            specific_files, rev_id, allow_pointless, strict, verbose,
 
269
            working_tree, local, reporter, message_callback, recursive,
 
270
            exclude, possible_master_transports, lossy):
 
271
        mutter('preparing to commit')
 
272
 
 
273
        if working_tree is None:
 
274
            raise BzrError("working_tree must be passed into commit().")
 
275
        else:
 
276
            self.work_tree = working_tree
 
277
            self.branch = self.work_tree.branch
 
278
            if getattr(self.work_tree, 'requires_rich_root', lambda: False)():
 
279
                if not self.branch.repository.supports_rich_root():
 
280
                    raise errors.RootNotRich()
 
281
        if message_callback is None:
 
282
            if message is not None:
 
283
                if isinstance(message, str):
 
284
                    message = message.decode(get_user_encoding())
 
285
                message_callback = lambda x: message
 
286
            else:
 
287
                raise BzrError("The message or message_callback keyword"
 
288
                               " parameter is required for commit().")
 
289
 
 
290
        self.bound_branch = None
 
291
        self.any_entries_deleted = False
 
292
        if exclude is not None:
 
293
            self.exclude = sorted(
 
294
                minimum_path_selection(exclude))
 
295
        else:
 
296
            self.exclude = []
 
297
        self.local = local
 
298
        self.master_branch = None
 
299
        self.recursive = recursive
 
300
        self.rev_id = None
 
301
        # self.specific_files is None to indicate no filter, or any iterable to
 
302
        # indicate a filter - [] means no files at all, as per iter_changes.
 
303
        if specific_files is not None:
 
304
            self.specific_files = sorted(
 
305
                minimum_path_selection(specific_files))
 
306
        else:
 
307
            self.specific_files = None
 
308
 
 
309
        self.allow_pointless = allow_pointless
 
310
        self.message_callback = message_callback
 
311
        self.timestamp = timestamp
 
312
        self.timezone = timezone
 
313
        self.committer = committer
 
314
        self.strict = strict
 
315
        self.verbose = verbose
 
316
 
 
317
        self.work_tree.lock_write()
 
318
        operation.add_cleanup(self.work_tree.unlock)
 
319
        self.parents = self.work_tree.get_parent_ids()
 
320
        # We can use record_iter_changes IFF iter_changes is compatible with
 
321
        # the command line parameters, and the repository has fast delta
 
322
        # generation. See bug 347649.
 
323
        self.use_record_iter_changes = (
 
324
            not self.exclude and 
 
325
            not self.branch.repository._format.supports_tree_reference and
 
326
            (self.branch.repository._format.fast_deltas or
 
327
             len(self.parents) < 2))
 
328
        self.pb = ui.ui_factory.nested_progress_bar()
 
329
        operation.add_cleanup(self.pb.finished)
 
330
        self.basis_revid = self.work_tree.last_revision()
 
331
        self.basis_tree = self.work_tree.basis_tree()
 
332
        self.basis_tree.lock_read()
 
333
        operation.add_cleanup(self.basis_tree.unlock)
 
334
        # Cannot commit with conflicts present.
 
335
        if len(self.work_tree.conflicts()) > 0:
 
336
            raise ConflictsInTree
 
337
 
 
338
        # Setup the bound branch variables as needed.
 
339
        self._check_bound_branch(operation, possible_master_transports)
 
340
 
 
341
        # Check that the working tree is up to date
 
342
        old_revno, old_revid, new_revno = self._check_out_of_date_tree()
 
343
 
 
344
        # Complete configuration setup
 
345
        if reporter is not None:
 
346
            self.reporter = reporter
 
347
        elif self.reporter is None:
 
348
            self.reporter = self._select_reporter()
 
349
        if self.config_stack is None:
 
350
            self.config_stack = self.work_tree.get_config_stack()
 
351
 
 
352
        self._set_specific_file_ids()
 
353
 
 
354
        # Setup the progress bar. As the number of files that need to be
 
355
        # committed in unknown, progress is reported as stages.
 
356
        # We keep track of entries separately though and include that
 
357
        # information in the progress bar during the relevant stages.
 
358
        self.pb_stage_name = ""
 
359
        self.pb_stage_count = 0
 
360
        self.pb_stage_total = 5
 
361
        if self.bound_branch:
 
362
            # 2 extra stages: "Uploading data to master branch" and "Merging
 
363
            # tags to master branch"
 
364
            self.pb_stage_total += 2
 
365
        self.pb.show_pct = False
 
366
        self.pb.show_spinner = False
 
367
        self.pb.show_eta = False
 
368
        self.pb.show_count = True
 
369
        self.pb.show_bar = True
 
370
 
 
371
        self._gather_parents()
 
372
        # After a merge, a selected file commit is not supported.
 
373
        # See 'bzr help merge' for an explanation as to why.
 
374
        if len(self.parents) > 1 and self.specific_files is not None:
 
375
            raise errors.CannotCommitSelectedFileMerge(self.specific_files)
 
376
        # Excludes are a form of selected file commit.
 
377
        if len(self.parents) > 1 and self.exclude:
 
378
            raise errors.CannotCommitSelectedFileMerge(self.exclude)
 
379
 
 
380
        # Collect the changes
 
381
        self._set_progress_stage("Collecting changes", counter=True)
 
382
        self._lossy = lossy
 
383
        self.builder = self.branch.get_commit_builder(self.parents,
 
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")
 
395
 
 
396
        try:
 
397
            self.builder.will_record_deletes()
 
398
            # find the location being committed to
370
399
            if self.bound_branch:
371
 
                # 2 extra stages: "Uploading data to master branch" and "Merging
372
 
                # tags to master branch"
373
 
                self.pb_stage_total += 2
374
 
            self.pb.show_pct = False
375
 
            self.pb.show_spinner = False
376
 
            self.pb.show_eta = False
377
 
            self.pb.show_count = True
378
 
            self.pb.show_bar = True
379
 
 
380
 
            # After a merge, a selected file commit is not supported.
381
 
            # See 'bzr help merge' for an explanation as to why.
382
 
            if len(self.parents) > 1 and self.specific_files is not None:
383
 
                raise CannotCommitSelectedFileMerge(self.specific_files)
384
 
            # Excludes are a form of selected file commit.
385
 
            if len(self.parents) > 1 and self.exclude:
386
 
                raise CannotCommitSelectedFileMerge(self.exclude)
387
 
 
388
 
            # Collect the changes
389
 
            self._set_progress_stage("Collecting changes", counter=True)
390
 
            self._lossy = lossy
391
 
            self.builder = self.branch.get_commit_builder(
392
 
                self.parents, self.config_stack, timestamp, timezone, committer,
393
 
                self.revprops, rev_id, lossy=lossy)
394
 
 
395
 
            if self.builder.updates_branch and self.bound_branch:
396
 
                self.builder.abort()
397
 
                raise AssertionError(
398
 
                    "bound branches not supported for commit builders "
399
 
                    "that update the branch")
400
 
 
401
 
            try:
402
 
                # find the location being committed to
403
 
                if self.bound_branch:
404
 
                    master_location = self.master_branch.base
405
 
                else:
406
 
                    master_location = self.branch.base
407
 
 
408
 
                # report the start of the commit
409
 
                self.reporter.started(new_revno, self.rev_id, master_location)
410
 
 
411
 
                self._update_builder_with_changes()
412
 
                self._check_pointless()
413
 
 
414
 
                # TODO: Now the new inventory is known, check for conflicts.
415
 
                # ADHB 2006-08-08: If this is done, populate_new_inv should not add
416
 
                # weave lines, because nothing should be recorded until it is known
417
 
                # that commit will succeed.
418
 
                self._set_progress_stage("Saving data locally")
419
 
                self.builder.finish_inventory()
420
 
 
421
 
                # Prompt the user for a commit message if none provided
422
 
                message = message_callback(self)
423
 
                self.message = message
424
 
 
425
 
                # Add revision data to the local branch
426
 
                self.rev_id = self.builder.commit(self.message)
427
 
 
428
 
            except Exception:
429
 
                mutter("aborting commit write group because of exception:")
430
 
                trace.log_exception_quietly()
431
 
                self.builder.abort()
432
 
                raise
433
 
 
434
 
            self._update_branches(old_revno, old_revid, new_revno)
435
 
 
436
 
            # Make the working tree be up to date with the branch. This
437
 
            # includes automatic changes scheduled to be made to the tree, such
438
 
            # as updating its basis and unversioning paths that were missing.
439
 
            self.work_tree.unversion(self.deleted_paths)
440
 
            self._set_progress_stage("Updating the working tree")
441
 
            self.work_tree.update_basis_by_delta(
442
 
                self.rev_id, self.builder.get_basis_delta())
443
 
            self.reporter.completed(new_revno, self.rev_id)
444
 
            self._process_post_hooks(old_revno, new_revno)
445
 
            return self.rev_id
 
400
                master_location = self.master_branch.base
 
401
            else:
 
402
                master_location = self.branch.base
 
403
 
 
404
            # report the start of the commit
 
405
            self.reporter.started(new_revno, self.rev_id, master_location)
 
406
 
 
407
            self._update_builder_with_changes()
 
408
            self._check_pointless()
 
409
 
 
410
            # TODO: Now the new inventory is known, check for conflicts.
 
411
            # ADHB 2006-08-08: If this is done, populate_new_inv should not add
 
412
            # weave lines, because nothing should be recorded until it is known
 
413
            # that commit will succeed.
 
414
            self._set_progress_stage("Saving data locally")
 
415
            self.builder.finish_inventory()
 
416
 
 
417
            # Prompt the user for a commit message if none provided
 
418
            message = message_callback(self)
 
419
            self.message = message
 
420
 
 
421
            # Add revision data to the local branch
 
422
            self.rev_id = self.builder.commit(self.message)
 
423
 
 
424
        except Exception as e:
 
425
            mutter("aborting commit write group because of exception:")
 
426
            trace.log_exception_quietly()
 
427
            self.builder.abort()
 
428
            raise
 
429
 
 
430
        self._update_branches(old_revno, old_revid, new_revno)
 
431
 
 
432
        # Make the working tree be up to date with the branch. This
 
433
        # includes automatic changes scheduled to be made to the tree, such
 
434
        # as updating its basis and unversioning paths that were missing.
 
435
        self.work_tree.unversion(self.deleted_ids)
 
436
        self._set_progress_stage("Updating the working tree")
 
437
        self.work_tree.update_basis_by_delta(self.rev_id,
 
438
             self.builder.get_basis_delta())
 
439
        self.reporter.completed(new_revno, self.rev_id)
 
440
        self._process_post_hooks(old_revno, new_revno)
 
441
        return self.rev_id
446
442
 
447
443
    def _update_branches(self, old_revno, old_revid, new_revno):
448
444
        """Update the master and local branch to the new revision.
470
466
                    self.branch.fetch(self.master_branch, self.rev_id)
471
467
 
472
468
            # and now do the commit locally.
473
 
            if new_revno is None:
474
 
                # Keep existing behaviour around ghosts
475
 
                new_revno = 1
476
469
            self.branch.set_last_revision_info(new_revno, self.rev_id)
477
470
        else:
478
471
            try:
479
472
                self._process_pre_hooks(old_revno, new_revno)
480
 
            except BaseException:
 
473
            except:
481
474
                # The commit builder will already have updated the branch,
482
475
                # revert it.
483
476
                self.branch.set_last_revision_info(old_revno, old_revid)
490
483
                self.master_branch.tags)
491
484
            if tag_conflicts:
492
485
                warning_lines = ['    ' + name for name, _, _ in tag_conflicts]
493
 
                note(gettext("Conflicting tags in bound branch:\n{0}".format(
494
 
                    "\n".join(warning_lines))))
 
486
                note( gettext("Conflicting tags in bound branch:\n{0}".format(
 
487
                    "\n".join(warning_lines))) )
495
488
 
496
489
    def _select_reporter(self):
497
490
        """Select the CommitReporter to use."""
509
502
            return
510
503
        raise PointlessCommit()
511
504
 
512
 
    def _check_bound_branch(self, stack, possible_master_transports=None):
 
505
    def _check_bound_branch(self, operation, possible_master_transports=None):
513
506
        """Check to see if the local branch is bound.
514
507
 
515
508
        If it is bound, then most of the commit will actually be
531
524
        # If the master branch is bound, we must fail
532
525
        master_bound_location = self.master_branch.get_bound_location()
533
526
        if master_bound_location:
534
 
            raise errors.CommitToDoubleBoundBranch(
535
 
                self.branch, self.master_branch, master_bound_location)
 
527
            raise errors.CommitToDoubleBoundBranch(self.branch,
 
528
                    self.master_branch, master_bound_location)
536
529
 
537
530
        # TODO: jam 20051230 We could automatically push local
538
531
        #       commits to the remote branch if they would fit.
540
533
        #       to local.
541
534
 
542
535
        # Make sure the local branch is identical to the master
543
 
        master_revid = self.master_branch.last_revision()
544
 
        local_revid = self.branch.last_revision()
545
 
        if local_revid != master_revid:
 
536
        master_info = self.master_branch.last_revision_info()
 
537
        local_info = self.branch.last_revision_info()
 
538
        if local_info != master_info:
546
539
            raise errors.BoundBranchOutOfDate(self.branch,
547
 
                                              self.master_branch)
 
540
                    self.master_branch)
548
541
 
549
542
        # Now things are ready to change the master branch
550
543
        # so grab the lock
551
544
        self.bound_branch = self.branch
552
 
        stack.enter_context(self.master_branch.lock_write())
 
545
        self.master_branch.lock_write()
 
546
        operation.add_cleanup(self.master_branch.unlock)
553
547
 
554
548
    def _check_out_of_date_tree(self):
555
549
        """Check that the working tree is up to date.
565
559
            # - in a checkout scenario the tree may have no
566
560
            # parents but the branch may do.
567
561
            first_tree_parent = breezy.revision.NULL_REVISION
568
 
        if (self.master_branch._format.stores_revno() or
569
 
                self.config_stack.get('calculate_revnos')):
570
 
            try:
571
 
                old_revno, master_last = self.master_branch.last_revision_info()
572
 
            except errors.UnsupportedOperation:
573
 
                master_last = self.master_branch.last_revision()
574
 
                old_revno = self.branch.revision_id_to_revno(master_last)
575
 
        else:
576
 
            master_last = self.master_branch.last_revision()
577
 
            old_revno = None
 
562
        old_revno, master_last = self.master_branch.last_revision_info()
578
563
        if master_last != first_tree_parent:
579
564
            if master_last != breezy.revision.NULL_REVISION:
580
565
                raise errors.OutOfDateTree(self.work_tree)
581
 
        if (old_revno is not None and
582
 
                self.branch.repository.has_revision(first_tree_parent)):
 
566
        if self.branch.repository.has_revision(first_tree_parent):
583
567
            new_revno = old_revno + 1
584
568
        else:
585
569
            # ghost parents never appear in revision history.
586
 
            new_revno = None
 
570
            new_revno = 1
587
571
        return old_revno, master_last, new_revno
588
572
 
589
573
    def _process_pre_hooks(self, old_revno, new_revno):
603
587
            # this would be nicer with twisted.python.reflect.namedAny
604
588
            for hook in hooks:
605
589
                result = eval(hook + '(branch, rev_id)',
606
 
                              {'branch': self.branch,
607
 
                               'breezy': breezy,
608
 
                               'rev_id': self.rev_id})
 
590
                              {'branch':self.branch,
 
591
                               'breezy':breezy,
 
592
                               'rev_id':self.rev_id})
609
593
        # process new style post commit hooks
610
594
        self._process_hooks("post_commit", old_revno, new_revno)
611
595
 
631
615
        if hook_name == "pre_commit":
632
616
            future_tree = self.builder.revision_tree()
633
617
            tree_delta = future_tree.changes_from(self.basis_tree,
634
 
                                                  include_root=True)
 
618
                                             include_root=True)
635
619
 
636
620
        for hook in Branch.hooks[hook_name]:
637
621
            # show the running hook in the progress bar. As hooks may
652
636
                     old_revno, old_revid, new_revno, self.rev_id,
653
637
                     tree_delta, future_tree)
654
638
 
 
639
    def _gather_parents(self):
 
640
        """Record the parents of a merge for merge detection."""
 
641
        # TODO: Make sure that this list doesn't contain duplicate
 
642
        # entries and the order is preserved when doing this.
 
643
        if self.use_record_iter_changes:
 
644
            return
 
645
        self.basis_inv = self.basis_tree.root_inventory
 
646
        self.parent_invs = [self.basis_inv]
 
647
        for revision in self.parents[1:]:
 
648
            if self.branch.repository.has_revision(revision):
 
649
                mutter('commit parent revision {%s}', revision)
 
650
                inventory = self.branch.repository.get_inventory(revision)
 
651
                self.parent_invs.append(inventory)
 
652
            else:
 
653
                mutter('commit parent ghost revision {%s}', revision)
 
654
 
655
655
    def _update_builder_with_changes(self):
656
656
        """Update the commit builder with the data about what has changed.
657
657
        """
 
658
        exclude = self.exclude
658
659
        specific_files = self.specific_files
659
 
        mutter("Selecting files for commit with filter %r", specific_files)
 
660
        mutter("Selecting files for commit with filter %s", specific_files)
660
661
 
661
662
        self._check_strict()
662
 
        iter_changes = self.work_tree.iter_changes(
663
 
            self.basis_tree, specific_files=specific_files)
664
 
        if self.exclude:
665
 
            iter_changes = filter_excluded(iter_changes, self.exclude)
666
 
        iter_changes = self._filter_iter_changes(iter_changes)
667
 
        for path, fs_hash in self.builder.record_iter_changes(
 
663
        if self.use_record_iter_changes:
 
664
            iter_changes = self.work_tree.iter_changes(self.basis_tree,
 
665
                specific_files=specific_files)
 
666
            iter_changes = self._filter_iter_changes(iter_changes)
 
667
            for file_id, path, fs_hash in self.builder.record_iter_changes(
668
668
                self.work_tree, self.basis_revid, iter_changes):
669
 
            self.work_tree._observed_sha1(path, fs_hash)
 
669
                self.work_tree._observed_sha1(file_id, path, fs_hash)
 
670
        else:
 
671
            # Build the new inventory
 
672
            self._populate_from_inventory()
 
673
            self._record_unselected()
 
674
            self._report_and_accumulate_deletes()
670
675
 
671
676
    def _filter_iter_changes(self, iter_changes):
672
677
        """Process iter_changes.
673
678
 
674
 
        This method reports on the changes in iter_changes to the user, and
 
679
        This method reports on the changes in iter_changes to the user, and 
675
680
        converts 'missing' entries in the iter_changes iterator to 'deleted'
676
681
        entries. 'missing' entries have their
677
682
 
680
685
        """
681
686
        reporter = self.reporter
682
687
        report_changes = reporter.is_verbose()
683
 
        deleted_paths = []
 
688
        deleted_ids = []
684
689
        for change in iter_changes:
685
690
            if report_changes:
686
 
                old_path = change.path[0]
687
 
                new_path = change.path[1]
688
 
                versioned = change.versioned[1]
689
 
            kind = change.kind[1]
690
 
            versioned = change.versioned[1]
 
691
                old_path = change[1][0]
 
692
                new_path = change[1][1]
 
693
                versioned = change[3][1]
 
694
            kind = change[6][1]
 
695
            versioned = change[3][1]
691
696
            if kind is None and versioned:
692
697
                # 'missing' path
693
698
                if report_changes:
694
699
                    reporter.missing(new_path)
695
 
                if change.kind[0] == 'symlink' and not self.work_tree.supports_symlinks():
696
 
                    trace.warning('Ignoring "%s" as symlinks are not '
697
 
                                  'supported on this filesystem.' % (change.path[0],))
698
 
                    continue
699
 
                deleted_paths.append(change.path[1])
 
700
                deleted_ids.append(change[0])
700
701
                # Reset the new path (None) and new versioned flag (False)
701
 
                change = change.discard_new()
702
 
                new_path = change.path[1]
 
702
                change = (change[0], (change[1][0], None), change[2],
 
703
                    (change[3][0], False)) + change[4:]
 
704
                new_path = change[1][1]
703
705
                versioned = False
704
706
            elif kind == 'tree-reference':
705
707
                if self.recursive == 'down':
706
 
                    self._commit_nested_tree(change.path[1])
707
 
            if change.versioned[0] or change.versioned[1]:
 
708
                    self._commit_nested_tree(change[0], change[1][1])
 
709
            if change[3][0] or change[3][1]:
708
710
                yield change
709
711
                if report_changes:
710
712
                    if new_path is None:
712
714
                    elif old_path is None:
713
715
                        reporter.snapshot_change(gettext('added'), new_path)
714
716
                    elif old_path != new_path:
715
 
                        reporter.renamed(gettext('renamed'),
716
 
                                         old_path, new_path)
 
717
                        reporter.renamed(gettext('renamed'), old_path, new_path)
717
718
                    else:
718
 
                        if (new_path
719
 
                                or self.work_tree.branch.repository._format.rich_root_data):
 
719
                        if (new_path or 
 
720
                            self.work_tree.branch.repository._format.rich_root_data):
720
721
                            # Don't report on changes to '' in non rich root
721
722
                            # repositories.
722
 
                            reporter.snapshot_change(
723
 
                                gettext('modified'), new_path)
 
723
                            reporter.snapshot_change(gettext('modified'), new_path)
724
724
            self._next_progress_entry()
725
 
        # Unversion files that were found to be deleted
726
 
        self.deleted_paths = deleted_paths
 
725
        # Unversion IDs that were found to be deleted
 
726
        self.deleted_ids = deleted_ids
 
727
 
 
728
    def _record_unselected(self):
 
729
        # If specific files are selected, then all un-selected files must be
 
730
        # recorded in their previous state. For more details, see
 
731
        # https://lists.ubuntu.com/archives/bazaar/2007q3/028476.html.
 
732
        if self.specific_files or self.exclude:
 
733
            specific_files = self.specific_files or []
 
734
            for path, old_ie in self.basis_inv.iter_entries():
 
735
                if self.builder.new_inventory.has_id(old_ie.file_id):
 
736
                    # already added - skip.
 
737
                    continue
 
738
                if (is_inside_any(specific_files, path)
 
739
                    and not is_inside_any(self.exclude, path)):
 
740
                    # was inside the selected path, and not excluded - if not
 
741
                    # present it has been deleted so skip.
 
742
                    continue
 
743
                # From here down it was either not selected, or was excluded:
 
744
                # We preserve the entry unaltered.
 
745
                ie = old_ie.copy()
 
746
                # Note: specific file commits after a merge are currently
 
747
                # prohibited. This test is for sanity/safety in case it's
 
748
                # required after that changes.
 
749
                if len(self.parents) > 1:
 
750
                    ie.revision = None
 
751
                self.builder.record_entry_contents(ie, self.parent_invs, path,
 
752
                    self.basis_tree, None)
 
753
 
 
754
    def _report_and_accumulate_deletes(self):
 
755
        if (isinstance(self.basis_inv, Inventory)
 
756
            and isinstance(self.builder.new_inventory, Inventory)):
 
757
            # the older Inventory classes provide a _byid dict, and building a
 
758
            # set from the keys of this dict is substantially faster than even
 
759
            # getting a set of ids from the inventory
 
760
            #
 
761
            # <lifeless> set(dict) is roughly the same speed as
 
762
            # set(iter(dict)) and both are significantly slower than
 
763
            # set(dict.keys())
 
764
            deleted_ids = set(self.basis_inv._byid.keys()) - \
 
765
               set(self.builder.new_inventory._byid.keys())
 
766
        else:
 
767
            deleted_ids = set(self.basis_inv) - set(self.builder.new_inventory)
 
768
        if deleted_ids:
 
769
            self.any_entries_deleted = True
 
770
            deleted = sorted([(self.basis_tree.id2path(file_id), file_id)
 
771
                for file_id in deleted_ids])
 
772
            # XXX: this is not quite directory-order sorting
 
773
            for path, file_id in deleted:
 
774
                self.builder.record_delete(path, file_id)
 
775
                self.reporter.deleted(path)
727
776
 
728
777
    def _check_strict(self):
729
778
        # XXX: when we use iter_changes this would likely be faster if
734
783
            for unknown in self.work_tree.unknowns():
735
784
                raise StrictCommitFailed()
736
785
 
737
 
    def _commit_nested_tree(self, path):
 
786
    def _populate_from_inventory(self):
 
787
        """Populate the CommitBuilder by walking the working tree inventory."""
 
788
        # Build the revision inventory.
 
789
        #
 
790
        # This starts by creating a new empty inventory. Depending on
 
791
        # which files are selected for commit, and what is present in the
 
792
        # current tree, the new inventory is populated. inventory entries
 
793
        # which are candidates for modification have their revision set to
 
794
        # None; inventory entries that are carried over untouched have their
 
795
        # revision set to their prior value.
 
796
        #
 
797
        # ESEPARATIONOFCONCERNS: this function is diffing and using the diff
 
798
        # results to create a new inventory at the same time, which results
 
799
        # in bugs like #46635.  Any reason not to use/enhance Tree.changes_from?
 
800
        # ADHB 11-07-2006
 
801
 
 
802
        specific_files = self.specific_files
 
803
        exclude = self.exclude
 
804
        report_changes = self.reporter.is_verbose()
 
805
        deleted_ids = []
 
806
        # A tree of paths that have been deleted. E.g. if foo/bar has been
 
807
        # deleted, then we have {'foo':{'bar':{}}}
 
808
        deleted_paths = {}
 
809
        # XXX: Note that entries may have the wrong kind because the entry does
 
810
        # not reflect the status on disk.
 
811
        # NB: entries will include entries within the excluded ids/paths
 
812
        # because iter_entries_by_dir has no 'exclude' facility today.
 
813
        entries = self.work_tree.iter_entries_by_dir(
 
814
            specific_file_ids=self.specific_file_ids, yield_parents=True)
 
815
        for path, existing_ie in entries:
 
816
            file_id = existing_ie.file_id
 
817
            name = existing_ie.name
 
818
            parent_id = existing_ie.parent_id
 
819
            kind = existing_ie.kind
 
820
            # Skip files that have been deleted from the working tree.
 
821
            # The deleted path ids are also recorded so they can be explicitly
 
822
            # unversioned later.
 
823
            if deleted_paths:
 
824
                path_segments = splitpath(path)
 
825
                deleted_dict = deleted_paths
 
826
                for segment in path_segments:
 
827
                    deleted_dict = deleted_dict.get(segment, None)
 
828
                    if not deleted_dict:
 
829
                        # We either took a path not present in the dict
 
830
                        # (deleted_dict was None), or we've reached an empty
 
831
                        # child dir in the dict, so are now a sub-path.
 
832
                        break
 
833
                else:
 
834
                    deleted_dict = None
 
835
                if deleted_dict is not None:
 
836
                    # the path has a deleted parent, do not add it.
 
837
                    continue
 
838
            if exclude and is_inside_any(exclude, path):
 
839
                # Skip excluded paths. Excluded paths are processed by
 
840
                # _update_builder_with_changes.
 
841
                continue
 
842
            content_summary = self.work_tree.path_content_summary(path)
 
843
            kind = content_summary[0]
 
844
            # Note that when a filter of specific files is given, we must only
 
845
            # skip/record deleted files matching that filter.
 
846
            if not specific_files or is_inside_any(specific_files, path):
 
847
                if kind == 'missing':
 
848
                    if not deleted_paths:
 
849
                        # path won't have been split yet.
 
850
                        path_segments = splitpath(path)
 
851
                    deleted_dict = deleted_paths
 
852
                    for segment in path_segments:
 
853
                        deleted_dict = deleted_dict.setdefault(segment, {})
 
854
                    self.reporter.missing(path)
 
855
                    self._next_progress_entry()
 
856
                    deleted_ids.append(file_id)
 
857
                    continue
 
858
            # TODO: have the builder do the nested commit just-in-time IF and
 
859
            # only if needed.
 
860
            if kind == 'tree-reference':
 
861
                # enforce repository nested tree policy.
 
862
                if (not self.work_tree.supports_tree_reference() or
 
863
                    # repository does not support it either.
 
864
                    not self.branch.repository._format.supports_tree_reference):
 
865
                    kind = 'directory'
 
866
                    content_summary = (kind, None, None, None)
 
867
                elif self.recursive == 'down':
 
868
                    nested_revision_id = self._commit_nested_tree(
 
869
                        file_id, path)
 
870
                    content_summary = (kind, None, None, nested_revision_id)
 
871
                else:
 
872
                    nested_revision_id = self.work_tree.get_reference_revision(file_id)
 
873
                    content_summary = (kind, None, None, nested_revision_id)
 
874
 
 
875
            # Record an entry for this item
 
876
            # Note: I don't particularly want to have the existing_ie
 
877
            # parameter but the test suite currently (28-Jun-07) breaks
 
878
            # without it thanks to a unicode normalisation issue. :-(
 
879
            definitely_changed = kind != existing_ie.kind
 
880
            self._record_entry(path, file_id, specific_files, kind, name,
 
881
                parent_id, definitely_changed, existing_ie, report_changes,
 
882
                content_summary)
 
883
 
 
884
        # Unversion IDs that were found to be deleted
 
885
        self.deleted_ids = deleted_ids
 
886
 
 
887
    def _commit_nested_tree(self, file_id, path):
738
888
        "Commit a nested tree."
739
 
        sub_tree = self.work_tree.get_nested_tree(path)
 
889
        sub_tree = self.work_tree.get_nested_tree(file_id, path)
740
890
        # FIXME: be more comprehensive here:
741
891
        # this works when both trees are in --trees repository,
742
892
        # but when both are bound to a different repository,
744
894
        # finally implement the explicit-caches approach design
745
895
        # a while back - RBC 20070306.
746
896
        if sub_tree.branch.repository.has_same_location(
747
 
                self.work_tree.branch.repository):
 
897
            self.work_tree.branch.repository):
748
898
            sub_tree.branch.repository = \
749
899
                self.work_tree.branch.repository
750
900
        try:
751
901
            return sub_tree.commit(message=None, revprops=self.revprops,
752
 
                                   recursive=self.recursive,
753
 
                                   message_callback=self.message_callback,
754
 
                                   timestamp=self.timestamp,
755
 
                                   timezone=self.timezone,
756
 
                                   committer=self.committer,
757
 
                                   allow_pointless=self.allow_pointless,
758
 
                                   strict=self.strict, verbose=self.verbose,
759
 
                                   local=self.local, reporter=self.reporter)
760
 
        except PointlessCommit:
761
 
            return self.work_tree.get_reference_revision(path)
 
902
                recursive=self.recursive,
 
903
                message_callback=self.message_callback,
 
904
                timestamp=self.timestamp, timezone=self.timezone,
 
905
                committer=self.committer,
 
906
                allow_pointless=self.allow_pointless,
 
907
                strict=self.strict, verbose=self.verbose,
 
908
                local=self.local, reporter=self.reporter)
 
909
        except errors.PointlessCommit:
 
910
            return self.work_tree.get_reference_revision(file_id)
 
911
 
 
912
    def _record_entry(self, path, file_id, specific_files, kind, name,
 
913
        parent_id, definitely_changed, existing_ie, report_changes,
 
914
        content_summary):
 
915
        "Record the new inventory entry for a path if any."
 
916
        # mutter('check %s {%s}', path, file_id)
 
917
        # mutter('%s selected for commit', path)
 
918
        if definitely_changed or existing_ie is None:
 
919
            ie = make_entry(kind, name, parent_id, file_id)
 
920
        else:
 
921
            ie = existing_ie.copy()
 
922
            ie.revision = None
 
923
        # For carried over entries we don't care about the fs hash - the repo
 
924
        # isn't generating a sha, so we're not saving computation time.
 
925
        _, _, fs_hash = self.builder.record_entry_contents(
 
926
            ie, self.parent_invs, path, self.work_tree, content_summary)
 
927
        if report_changes:
 
928
            self._report_change(ie, path)
 
929
        if fs_hash:
 
930
            self.work_tree._observed_sha1(ie.file_id, path, fs_hash)
 
931
        return ie
 
932
 
 
933
    def _report_change(self, ie, path):
 
934
        """Report a change to the user.
 
935
 
 
936
        The change that has occurred is described relative to the basis
 
937
        inventory.
 
938
        """
 
939
        if (self.basis_inv.has_id(ie.file_id)):
 
940
            basis_ie = self.basis_inv[ie.file_id]
 
941
        else:
 
942
            basis_ie = None
 
943
        change = ie.describe_change(basis_ie, ie)
 
944
        if change in (InventoryEntry.RENAMED,
 
945
            InventoryEntry.MODIFIED_AND_RENAMED):
 
946
            old_path = self.basis_inv.id2path(ie.file_id)
 
947
            self.reporter.renamed(change, old_path, path)
 
948
            self._next_progress_entry()
 
949
        else:
 
950
            if change == gettext('unchanged'):
 
951
                return
 
952
            self.reporter.snapshot_change(change, path)
 
953
            self._next_progress_entry()
762
954
 
763
955
    def _set_progress_stage(self, name, counter=False):
764
956
        """Set the progress stage and emit an update to the progress bar."""
778
970
    def _emit_progress(self):
779
971
        if self.pb_entries_count is not None:
780
972
            text = gettext("{0} [{1}] - Stage").format(self.pb_stage_name,
781
 
                                                       self.pb_entries_count)
 
973
                self.pb_entries_count)
782
974
        else:
783
975
            text = gettext("%s - Stage") % (self.pb_stage_name, )
784
976
        self.pb.update(text, self.pb_stage_count, self.pb_stage_total)
 
977
 
 
978
    def _set_specific_file_ids(self):
 
979
        """populate self.specific_file_ids if we will use it."""
 
980
        if not self.use_record_iter_changes:
 
981
            # If provided, ensure the specified files are versioned
 
982
            if self.specific_files is not None:
 
983
                # Note: This routine is being called because it raises
 
984
                # PathNotVersionedError as a side effect of finding the IDs. We
 
985
                # later use the ids we found as input to the working tree
 
986
                # inventory iterator, so we only consider those ids rather than
 
987
                # examining the whole tree again.
 
988
                # XXX: Dont we have filter_unversioned to do this more
 
989
                # cheaply?
 
990
                self.specific_file_ids = tree.find_ids_across_trees(
 
991
                    self.specific_files, [self.basis_tree, self.work_tree])
 
992
            else:
 
993
                self.specific_file_ids = None