/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: John Arbash Meinel
  • Date: 2007-10-10 21:18:06 UTC
  • mto: This revision was merged to the branch mainline in revision 2909.
  • Revision ID: john@arbash-meinel.com-20071010211806-2j9rg6wzrqh7yy4u
Switch from __new__ to __init__ to avoid potential pyrex upgrade problems.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commit.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
18
# The newly committed revision is going to have a shape corresponding
19
 
# to that of the working tree.  Files that are not in the
 
19
# to that of the working inventory.  Files that are not in the
20
20
# working tree and that were in the predecessor are reported as
21
21
# removed --- this can include files that were either removed from the
22
22
# inventory or deleted in the working tree.  If they were only
25
25
# We then consider the remaining entries, which will be in the new
26
26
# version.  Directory entries are simply copied across.  File entries
27
27
# must be checked to see if a new version of the file should be
28
 
# recorded.  For each parent revision tree, we check to see what
 
28
# recorded.  For each parent revision inventory, we check to see what
29
29
# version of the file was present.  If the file was present in at
30
30
# least one tree, and if it was the same version in all the trees,
31
31
# then we can just refer to that version.  Otherwise, a new version
49
49
# TODO: Change the parameter 'rev_id' to 'revision_id' to be consistent with
50
50
# the rest of the code; add a deprecation of the old name.
51
51
 
 
52
import os
 
53
import re
 
54
import sys
 
55
import time
 
56
 
 
57
from cStringIO import StringIO
 
58
 
52
59
from bzrlib import (
53
60
    debug,
54
61
    errors,
55
 
    revision,
56
 
    trace,
 
62
    inventory,
57
63
    tree,
58
64
    )
59
65
from bzrlib.branch import Branch
60
 
from bzrlib.cleanup import OperationWithCleanups
61
66
import bzrlib.config
62
67
from bzrlib.errors import (BzrError, PointlessCommit,
63
68
                           ConflictsInTree,
64
69
                           StrictCommitFailed
65
70
                           )
66
 
from bzrlib.osutils import (get_user_encoding,
67
 
                            is_inside_any,
 
71
from bzrlib.osutils import (kind_marker, isdir,isfile, is_inside_any,
 
72
                            is_inside_or_parent_of_any,
68
73
                            minimum_path_selection,
69
 
                            splitpath,
70
 
                            )
71
 
from bzrlib.trace import mutter, note, is_quiet
72
 
from bzrlib.inventory import Inventory, InventoryEntry, make_entry
 
74
                            quotefn, sha_file, split_lines)
 
75
from bzrlib.testament import Testament
 
76
from bzrlib.trace import mutter, note, warning, is_quiet
 
77
from bzrlib.xml5 import serializer_v5
 
78
from bzrlib.inventory import Inventory, InventoryEntry
73
79
from bzrlib import symbol_versioning
 
80
from bzrlib.symbol_versioning import (deprecated_passed,
 
81
        deprecated_function,
 
82
        DEPRECATED_PARAMETER)
 
83
from bzrlib.workingtree import WorkingTree
74
84
from bzrlib.urlutils import unescape_for_display
75
85
import bzrlib.ui
76
86
 
79
89
    """I report on progress of a commit."""
80
90
 
81
91
    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)
86
92
        pass
87
93
 
88
94
    def snapshot_change(self, change, path):
91
97
    def completed(self, revno, rev_id):
92
98
        pass
93
99
 
94
 
    def deleted(self, path):
 
100
    def deleted(self, file_id):
 
101
        pass
 
102
 
 
103
    def escaped(self, escape_count, message):
95
104
        pass
96
105
 
97
106
    def missing(self, path):
114
123
        note(format, *args)
115
124
 
116
125
    def snapshot_change(self, change, path):
117
 
        if path == '' and change in ('added', 'modified'):
 
126
        if change == 'unchanged':
 
127
            return
 
128
        if change == 'added' and path == '':
118
129
            return
119
130
        self._note("%s %s", change, path)
120
131
 
121
132
    def started(self, revno, rev_id, location=None):
122
133
        if location is not None:
123
 
            location = ' to: ' + unescape_for_display(location, 'utf-8')
 
134
            location = ' to "' + unescape_for_display(location, 'utf-8') + '"'
124
135
        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
136
            location = ''
131
 
        self._note('Committing%s', location)
 
137
        self._note('Committing revision %d%s.', revno, location)
132
138
 
133
139
    def completed(self, revno, rev_id):
134
140
        self._note('Committed revision %d.', revno)
135
 
        # self._note goes to the console too; so while we want to log the
136
 
        # rev_id, we can't trivially only log it. (See bug 526425). Long
137
 
        # term we should rearrange the reporting structure, but for now
138
 
        # we just mutter seperately. We mutter the revid and revno together
139
 
        # so that concurrent bzr invocations won't lead to confusion.
140
 
        mutter('Committed revid %s as revno %d.', rev_id, revno)
141
 
 
142
 
    def deleted(self, path):
143
 
        self._note('deleted %s', path)
 
141
 
 
142
    def deleted(self, file_id):
 
143
        self._note('deleted %s', file_id)
 
144
 
 
145
    def escaped(self, escape_count, message):
 
146
        self._note("replaced %d control characters in message", escape_count)
144
147
 
145
148
    def missing(self, path):
146
149
        self._note('missing %s', path)
174
177
        self.reporter = reporter
175
178
        self.config = config
176
179
 
177
 
    @staticmethod
178
 
    def update_revprops(revprops, branch, authors=None, author=None,
179
 
                        local=False, possible_master_transports=None):
180
 
        if revprops is None:
181
 
            revprops = {}
182
 
        if possible_master_transports is None:
183
 
            possible_master_transports = []
184
 
        if not 'branch-nick' in revprops:
185
 
            revprops['branch-nick'] = branch._get_nick(
186
 
                local,
187
 
                possible_master_transports)
188
 
        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
 
            if 'author' in revprops or 'authors' in revprops:
193
 
                # XXX: maybe we should just accept one of them?
194
 
                raise AssertionError('author property given twice')
195
 
            if authors:
196
 
                for individual in authors:
197
 
                    if '\n' in individual:
198
 
                        raise AssertionError('\\n is not a valid character '
199
 
                                'in an author identity')
200
 
                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
 
        return revprops
213
 
 
214
180
    def commit(self,
215
181
               message=None,
216
182
               timestamp=None,
227
193
               reporter=None,
228
194
               config=None,
229
195
               message_callback=None,
230
 
               recursive='down',
231
 
               exclude=None,
232
 
               possible_master_transports=None):
 
196
               recursive='down'):
233
197
        """Commit working copy as a new revision.
234
198
 
235
199
        :param message: the commit message (it or message_callback is required)
236
 
        :param message_callback: A callback: message = message_callback(cmt_obj)
237
200
 
238
201
        :param timestamp: if not None, seconds-since-epoch for a
239
202
            postdated/predated commit.
240
203
 
241
 
        :param specific_files: If not None, commit only those files. An empty
242
 
            list means 'commit no files'.
 
204
        :param specific_files: If true, commit only those files.
243
205
 
244
206
        :param rev_id: If set, use this as the new revision id.
245
207
            Useful for test or import commands that need to tightly
259
221
        :param verbose: if True and the reporter is not None, report everything
260
222
        :param recursive: If set to 'down', commit in any subtrees that have
261
223
            pending changes of any sort during this commit.
262
 
        :param exclude: None or a list of relative paths to exclude from the
263
 
            commit. Pending changes to excluded files will be ignored by the
264
 
            commit.
265
224
        """
266
 
        operation = OperationWithCleanups(self._commit)
267
 
        self.revprops = revprops or {}
268
 
        # XXX: Can be set on __init__ or passed in - this is a bit ugly.
269
 
        self.config = config or self.config
270
 
        return operation.run(
271
 
               message=message,
272
 
               timestamp=timestamp,
273
 
               timezone=timezone,
274
 
               committer=committer,
275
 
               specific_files=specific_files,
276
 
               rev_id=rev_id,
277
 
               allow_pointless=allow_pointless,
278
 
               strict=strict,
279
 
               verbose=verbose,
280
 
               working_tree=working_tree,
281
 
               local=local,
282
 
               reporter=reporter,
283
 
               message_callback=message_callback,
284
 
               recursive=recursive,
285
 
               exclude=exclude,
286
 
               possible_master_transports=possible_master_transports)
287
 
 
288
 
    def _commit(self, operation, message, timestamp, timezone, committer,
289
 
            specific_files, rev_id, allow_pointless, strict, verbose,
290
 
            working_tree, local, reporter, message_callback, recursive,
291
 
            exclude, possible_master_transports):
292
225
        mutter('preparing to commit')
293
226
 
294
227
        if working_tree is None:
302
235
        if message_callback is None:
303
236
            if message is not None:
304
237
                if isinstance(message, str):
305
 
                    message = message.decode(get_user_encoding())
 
238
                    message = message.decode(bzrlib.user_encoding)
306
239
                message_callback = lambda x: message
307
240
            else:
308
241
                raise BzrError("The message or message_callback keyword"
309
242
                               " parameter is required for commit().")
310
243
 
311
244
        self.bound_branch = None
 
245
        self.any_entries_changed = False
312
246
        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
247
        self.local = local
319
248
        self.master_branch = None
 
249
        self.master_locked = False
320
250
        self.recursive = recursive
321
251
        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
252
        if specific_files is not None:
325
253
            self.specific_files = sorted(
326
254
                minimum_path_selection(specific_files))
327
255
        else:
328
256
            self.specific_files = None
329
 
            
 
257
        self.specific_file_ids = None
330
258
        self.allow_pointless = allow_pointless
 
259
        self.revprops = revprops
331
260
        self.message_callback = message_callback
332
261
        self.timestamp = timestamp
333
262
        self.timezone = timezone
336
265
        self.verbose = verbose
337
266
 
338
267
        self.work_tree.lock_write()
339
 
        operation.add_cleanup(self.work_tree.unlock)
340
 
        self.parents = self.work_tree.get_parent_ids()
341
 
        # We can use record_iter_changes IFF iter_changes is compatible with
342
 
        # the command line parameters, and the repository has fast delta
343
 
        # generation. See bug 347649.
344
 
        self.use_record_iter_changes = (
345
 
            not self.exclude and 
346
 
            not self.branch.repository._format.supports_tree_reference and
347
 
            (self.branch.repository._format.fast_deltas or
348
 
             len(self.parents) < 2))
349
268
        self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
350
 
        operation.add_cleanup(self.pb.finished)
351
 
        self.basis_revid = self.work_tree.last_revision()
352
269
        self.basis_tree = self.work_tree.basis_tree()
353
270
        self.basis_tree.lock_read()
354
 
        operation.add_cleanup(self.basis_tree.unlock)
355
 
        # Cannot commit with conflicts present.
356
 
        if len(self.work_tree.conflicts()) > 0:
357
 
            raise ConflictsInTree
358
 
 
359
 
        # Setup the bound branch variables as needed.
360
 
        self._check_bound_branch(operation, possible_master_transports)
361
 
 
362
 
        # Check that the working tree is up to date
363
 
        old_revno, new_revno = self._check_out_of_date_tree()
364
 
 
365
 
        # Complete configuration setup
366
 
        if reporter is not None:
367
 
            self.reporter = reporter
368
 
        elif self.reporter is None:
369
 
            self.reporter = self._select_reporter()
370
 
        if self.config is None:
371
 
            self.config = self.branch.get_config()
372
 
 
373
 
        self._set_specific_file_ids()
374
 
 
375
 
        # Setup the progress bar. As the number of files that need to be
376
 
        # committed in unknown, progress is reported as stages.
377
 
        # We keep track of entries separately though and include that
378
 
        # information in the progress bar during the relevant stages.
379
 
        self.pb_stage_name = ""
380
 
        self.pb_stage_count = 0
381
 
        self.pb_stage_total = 5
382
 
        if self.bound_branch:
383
 
            self.pb_stage_total += 1
384
 
        self.pb.show_pct = False
385
 
        self.pb.show_spinner = False
386
 
        self.pb.show_eta = False
387
 
        self.pb.show_count = True
388
 
        self.pb.show_bar = True
389
 
 
390
 
        self._gather_parents()
391
 
        # After a merge, a selected file commit is not supported.
392
 
        # See 'bzr help merge' for an explanation as to why.
393
 
        if len(self.parents) > 1 and self.specific_files is not None:
394
 
            raise errors.CannotCommitSelectedFileMerge(self.specific_files)
395
 
        # Excludes are a form of selected file commit.
396
 
        if len(self.parents) > 1 and self.exclude:
397
 
            raise errors.CannotCommitSelectedFileMerge(self.exclude)
398
 
 
399
 
        # Collect the changes
400
 
        self._set_progress_stage("Collecting changes", counter=True)
401
 
        self.builder = self.branch.get_commit_builder(self.parents,
402
 
            self.config, timestamp, timezone, committer, self.revprops, rev_id)
403
 
 
404
271
        try:
405
 
            self.builder.will_record_deletes()
406
 
            # find the location being committed to
407
 
            if self.bound_branch:
408
 
                master_location = self.master_branch.base
409
 
            else:
410
 
                master_location = self.branch.base
411
 
 
412
 
            # report the start of the commit
413
 
            self.reporter.started(new_revno, self.rev_id, master_location)
414
 
 
415
 
            self._update_builder_with_changes()
416
 
            self._check_pointless()
417
 
 
418
 
            # TODO: Now the new inventory is known, check for conflicts.
419
 
            # ADHB 2006-08-08: If this is done, populate_new_inv should not add
420
 
            # weave lines, because nothing should be recorded until it is known
421
 
            # that commit will succeed.
422
 
            self._set_progress_stage("Saving data locally")
423
 
            self.builder.finish_inventory()
424
 
 
425
 
            # Prompt the user for a commit message if none provided
426
 
            message = message_callback(self)
427
 
            self.message = message
428
 
 
429
 
            # Add revision data to the local branch
430
 
            self.rev_id = self.builder.commit(self.message)
431
 
 
432
 
        except Exception, e:
433
 
            mutter("aborting commit write group because of exception:")
434
 
            trace.log_exception_quietly()
435
 
            note("aborting commit write group: %r" % (e,))
436
 
            self.builder.abort()
437
 
            raise
438
 
 
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)
452
 
 
453
 
        # Make the working tree be up to date with the branch. This
454
 
        # includes automatic changes scheduled to be made to the tree, such
455
 
        # as updating its basis and unversioning paths that were missing.
456
 
        self.work_tree.unversion(self.deleted_ids)
457
 
        self._set_progress_stage("Updating the working tree")
458
 
        self.work_tree.update_basis_by_delta(self.rev_id,
459
 
             self.builder.get_basis_delta())
460
 
        self.reporter.completed(new_revno, self.rev_id)
461
 
        self._process_post_hooks(old_revno, new_revno)
 
272
            # Cannot commit with conflicts present.
 
273
            if len(self.work_tree.conflicts()) > 0:
 
274
                raise ConflictsInTree
 
275
 
 
276
            # Setup the bound branch variables as needed.
 
277
            self._check_bound_branch()
 
278
 
 
279
            # Check that the working tree is up to date
 
280
            old_revno, new_revno = self._check_out_of_date_tree()
 
281
 
 
282
            # Complete configuration setup
 
283
            if reporter is not None:
 
284
                self.reporter = reporter
 
285
            elif self.reporter is None:
 
286
                self.reporter = self._select_reporter()
 
287
            if self.config is None:
 
288
                self.config = self.branch.get_config()
 
289
 
 
290
            # If provided, ensure the specified files are versioned
 
291
            if self.specific_files is not None:
 
292
                # Note: This routine is being called because it raises
 
293
                # PathNotVersionedError as a side effect of finding the IDs. We
 
294
                # later use the ids we found as input to the working tree
 
295
                # inventory iterator, so we only consider those ids rather than
 
296
                # examining the whole tree again.
 
297
                # XXX: Dont we have filter_unversioned to do this more
 
298
                # cheaply?
 
299
                self.specific_file_ids = tree.find_ids_across_trees(
 
300
                    specific_files, [self.basis_tree, self.work_tree])
 
301
 
 
302
            # Setup the progress bar. As the number of files that need to be
 
303
            # committed in unknown, progress is reported as stages.
 
304
            # We keep track of entries separately though and include that
 
305
            # information in the progress bar during the relevant stages.
 
306
            self.pb_stage_name = ""
 
307
            self.pb_stage_count = 0
 
308
            self.pb_stage_total = 5
 
309
            if self.bound_branch:
 
310
                self.pb_stage_total += 1
 
311
            self.pb.show_pct = False
 
312
            self.pb.show_spinner = False
 
313
            self.pb.show_eta = False
 
314
            self.pb.show_count = True
 
315
            self.pb.show_bar = True
 
316
 
 
317
            # After a merge, a selected file commit is not supported.
 
318
            # See 'bzr help merge' for an explanation as to why.
 
319
            self.basis_inv = self.basis_tree.inventory
 
320
            self._gather_parents()
 
321
            if len(self.parents) > 1 and self.specific_files:
 
322
                raise errors.CannotCommitSelectedFileMerge(self.specific_files)
 
323
 
 
324
            # Collect the changes
 
325
            self._set_progress_stage("Collecting changes",
 
326
                    entries_title="Directory")
 
327
            self.builder = self.branch.get_commit_builder(self.parents,
 
328
                self.config, timestamp, timezone, committer, revprops, rev_id)
 
329
            
 
330
            try:
 
331
                # find the location being committed to
 
332
                if self.bound_branch:
 
333
                    master_location = self.master_branch.base
 
334
                else:
 
335
                    master_location = self.branch.base
 
336
 
 
337
                # report the start of the commit
 
338
                self.reporter.started(new_revno, self.rev_id, master_location)
 
339
 
 
340
                self._update_builder_with_changes()
 
341
                self._check_pointless()
 
342
 
 
343
                # TODO: Now the new inventory is known, check for conflicts.
 
344
                # ADHB 2006-08-08: If this is done, populate_new_inv should not add
 
345
                # weave lines, because nothing should be recorded until it is known
 
346
                # that commit will succeed.
 
347
                self._set_progress_stage("Saving data locally")
 
348
                self.builder.finish_inventory()
 
349
 
 
350
                # Prompt the user for a commit message if none provided
 
351
                message = message_callback(self)
 
352
                assert isinstance(message, unicode), type(message)
 
353
                self.message = message
 
354
                self._escape_commit_message()
 
355
 
 
356
                # Add revision data to the local branch
 
357
                self.rev_id = self.builder.commit(self.message)
 
358
 
 
359
            except:
 
360
                self.builder.abort()
 
361
                raise
 
362
 
 
363
            self._process_pre_hooks(old_revno, new_revno)
 
364
 
 
365
            # Upload revision data to the master.
 
366
            # this will propagate merged revisions too if needed.
 
367
            if self.bound_branch:
 
368
                self._set_progress_stage("Uploading data to master branch")
 
369
                self.master_branch.repository.fetch(self.branch.repository,
 
370
                                                    revision_id=self.rev_id)
 
371
                # now the master has the revision data
 
372
                # 'commit' to the master first so a timeout here causes the
 
373
                # local branch to be out of date
 
374
                self.master_branch.set_last_revision_info(new_revno,
 
375
                                                          self.rev_id)
 
376
 
 
377
            # and now do the commit locally.
 
378
            self.branch.set_last_revision_info(new_revno, self.rev_id)
 
379
 
 
380
            # Make the working tree up to date with the branch
 
381
            self._set_progress_stage("Updating the working tree")
 
382
            rev_tree = self.builder.revision_tree()
 
383
            self.work_tree.set_parent_trees([(self.rev_id, rev_tree)])
 
384
            self.reporter.completed(new_revno, self.rev_id)
 
385
            self._process_post_hooks(old_revno, new_revno)
 
386
        finally:
 
387
            self._cleanup()
462
388
        return self.rev_id
463
389
 
464
390
    def _select_reporter(self):
473
399
        # A merge with no effect on files
474
400
        if len(self.parents) > 1:
475
401
            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)):
 
402
        # work around the fact that a newly-initted tree does differ from its
 
403
        # basis
 
404
        if len(self.basis_inv) == 0 and len(self.builder.new_inventory) == 1:
484
405
            raise PointlessCommit()
485
 
        if self.builder.any_changes():
 
406
        # Shortcut, if the number of entries changes, then we obviously have
 
407
        # a change
 
408
        if len(self.builder.new_inventory) != len(self.basis_inv):
 
409
            return
 
410
        # If length == 1, then we only have the root entry. Which means
 
411
        # that there is no real difference (only the root could be different)
 
412
        if len(self.builder.new_inventory) != 1 and (self.any_entries_changed
 
413
            or self.any_entries_deleted):
486
414
            return
487
415
        raise PointlessCommit()
488
416
 
489
 
    def _check_bound_branch(self, operation, possible_master_transports=None):
 
417
    def _check_bound_branch(self):
490
418
        """Check to see if the local branch is bound.
491
419
 
492
420
        If it is bound, then most of the commit will actually be
497
425
            raise errors.LocalRequiresBoundBranch()
498
426
 
499
427
        if not self.local:
500
 
            self.master_branch = self.branch.get_master_branch(
501
 
                possible_master_transports)
 
428
            self.master_branch = self.branch.get_master_branch()
502
429
 
503
430
        if not self.master_branch:
504
431
            # make this branch the reference branch for out of date checks.
515
442
        #       commits to the remote branch if they would fit.
516
443
        #       But for now, just require remote to be identical
517
444
        #       to local.
518
 
 
 
445
        
519
446
        # Make sure the local branch is identical to the master
520
447
        master_info = self.master_branch.last_revision_info()
521
448
        local_info = self.branch.last_revision_info()
527
454
        # so grab the lock
528
455
        self.bound_branch = self.branch
529
456
        self.master_branch.lock_write()
530
 
        operation.add_cleanup(self.master_branch.unlock)
 
457
        self.master_locked = True
531
458
 
532
459
    def _check_out_of_date_tree(self):
533
460
        """Check that the working tree is up to date.
578
505
    def _process_hooks(self, hook_name, old_revno, new_revno):
579
506
        if not Branch.hooks[hook_name]:
580
507
            return
581
 
 
 
508
        
582
509
        # new style commit hooks:
583
510
        if not self.bound_branch:
584
511
            hook_master = self.branch
593
520
            old_revid = self.parents[0]
594
521
        else:
595
522
            old_revid = bzrlib.revision.NULL_REVISION
596
 
 
 
523
        
597
524
        if hook_name == "pre_commit":
598
525
            future_tree = self.builder.revision_tree()
599
526
            tree_delta = future_tree.changes_from(self.basis_tree,
600
527
                                             include_root=True)
601
 
 
 
528
        
602
529
        for hook in Branch.hooks[hook_name]:
603
530
            # show the running hook in the progress bar. As hooks may
604
531
            # end up doing nothing (e.g. because they are not configured by
618
545
                     old_revno, old_revid, new_revno, self.rev_id,
619
546
                     tree_delta, future_tree)
620
547
 
 
548
    def _cleanup(self):
 
549
        """Cleanup any open locks, progress bars etc."""
 
550
        cleanups = [self._cleanup_bound_branch,
 
551
                    self.basis_tree.unlock,
 
552
                    self.work_tree.unlock,
 
553
                    self.pb.finished]
 
554
        found_exception = None
 
555
        for cleanup in cleanups:
 
556
            try:
 
557
                cleanup()
 
558
            # we want every cleanup to run no matter what.
 
559
            # so we have a catchall here, but we will raise the
 
560
            # last encountered exception up the stack: and
 
561
            # typically this will be useful enough.
 
562
            except Exception, e:
 
563
                found_exception = e
 
564
        if found_exception is not None: 
 
565
            # don't do a plan raise, because the last exception may have been
 
566
            # trashed, e is our sure-to-work exception even though it loses the
 
567
            # full traceback. XXX: RBC 20060421 perhaps we could check the
 
568
            # exc_info and if its the same one do a plain raise otherwise 
 
569
            # 'raise e' as we do now.
 
570
            raise e
 
571
 
 
572
    def _cleanup_bound_branch(self):
 
573
        """Executed at the end of a try/finally to cleanup a bound branch.
 
574
 
 
575
        If the branch wasn't bound, this is a no-op.
 
576
        If it was, it resents self.branch to the local branch, instead
 
577
        of being the master.
 
578
        """
 
579
        if not self.bound_branch:
 
580
            return
 
581
        if self.master_locked:
 
582
            self.master_branch.unlock()
 
583
 
 
584
    def _escape_commit_message(self):
 
585
        """Replace xml-incompatible control characters."""
 
586
        # FIXME: RBC 20060419 this should be done by the revision
 
587
        # serialiser not by commit. Then we can also add an unescaper
 
588
        # in the deserializer and start roundtripping revision messages
 
589
        # precisely. See repository_implementations/test_repository.py
 
590
        
 
591
        # Python strings can include characters that can't be
 
592
        # represented in well-formed XML; escape characters that
 
593
        # aren't listed in the XML specification
 
594
        # (http://www.w3.org/TR/REC-xml/#NT-Char).
 
595
        self.message, escape_count = re.subn(
 
596
            u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
 
597
            lambda match: match.group(0).encode('unicode_escape'),
 
598
            self.message)
 
599
        if escape_count:
 
600
            self.reporter.escaped(escape_count, self.message)
 
601
 
621
602
    def _gather_parents(self):
622
603
        """Record the parents of a merge for merge detection."""
623
 
        # TODO: Make sure that this list doesn't contain duplicate
 
604
        # TODO: Make sure that this list doesn't contain duplicate 
624
605
        # entries and the order is preserved when doing this.
625
 
        if self.use_record_iter_changes:
626
 
            return
627
 
        self.basis_inv = self.basis_tree.inventory
 
606
        self.parents = self.work_tree.get_parent_ids()
628
607
        self.parent_invs = [self.basis_inv]
629
608
        for revision in self.parents[1:]:
630
609
            if self.branch.repository.has_revision(revision):
637
616
    def _update_builder_with_changes(self):
638
617
        """Update the commit builder with the data about what has changed.
639
618
        """
640
 
        exclude = self.exclude
 
619
        # Build the revision inventory.
 
620
        #
 
621
        # This starts by creating a new empty inventory. Depending on
 
622
        # which files are selected for commit, and what is present in the
 
623
        # current tree, the new inventory is populated. inventory entries 
 
624
        # which are candidates for modification have their revision set to
 
625
        # None; inventory entries that are carried over untouched have their
 
626
        # revision set to their prior value.
 
627
        #
 
628
        # ESEPARATIONOFCONCERNS: this function is diffing and using the diff
 
629
        # results to create a new inventory at the same time, which results
 
630
        # in bugs like #46635.  Any reason not to use/enhance Tree.changes_from?
 
631
        # ADHB 11-07-2006
 
632
 
641
633
        specific_files = self.specific_files
642
634
        mutter("Selecting files for commit with filter %s", specific_files)
643
635
 
644
 
        self._check_strict()
645
 
        if self.use_record_iter_changes:
646
 
            iter_changes = self.work_tree.iter_changes(self.basis_tree,
647
 
                specific_files=specific_files)
648
 
            iter_changes = self._filter_iter_changes(iter_changes)
649
 
            for file_id, path, fs_hash in self.builder.record_iter_changes(
650
 
                self.work_tree, self.basis_revid, iter_changes):
651
 
                self.work_tree._observed_sha1(file_id, path, fs_hash)
652
 
        else:
653
 
            # Build the new inventory
654
 
            self._populate_from_inventory()
655
 
            self._record_unselected()
656
 
            self._report_and_accumulate_deletes()
657
 
 
658
 
    def _filter_iter_changes(self, iter_changes):
659
 
        """Process iter_changes.
660
 
 
661
 
        This method reports on the changes in iter_changes to the user, and 
662
 
        converts 'missing' entries in the iter_changes iterator to 'deleted'
663
 
        entries. 'missing' entries have their
664
 
 
665
 
        :param iter_changes: An iter_changes to process.
666
 
        :return: A generator of changes.
667
 
        """
668
 
        reporter = self.reporter
669
 
        report_changes = reporter.is_verbose()
670
 
        deleted_ids = []
671
 
        for change in iter_changes:
672
 
            if report_changes:
673
 
                old_path = change[1][0]
674
 
                new_path = change[1][1]
675
 
                versioned = change[3][1]
676
 
            kind = change[6][1]
677
 
            versioned = change[3][1]
678
 
            if kind is None and versioned:
679
 
                # 'missing' path
680
 
                if report_changes:
681
 
                    reporter.missing(new_path)
682
 
                deleted_ids.append(change[0])
683
 
                # Reset the new path (None) and new versioned flag (False)
684
 
                change = (change[0], (change[1][0], None), change[2],
685
 
                    (change[3][0], False)) + change[4:]
686
 
            elif kind == 'tree-reference':
687
 
                if self.recursive == 'down':
688
 
                    self._commit_nested_tree(change[0], change[1][1])
689
 
            if change[3][0] or change[3][1]:
690
 
                yield change
691
 
                if report_changes:
692
 
                    if new_path is None:
693
 
                        reporter.deleted(old_path)
694
 
                    elif old_path is None:
695
 
                        reporter.snapshot_change('added', new_path)
696
 
                    elif old_path != new_path:
697
 
                        reporter.renamed('renamed', old_path, new_path)
698
 
                    else:
699
 
                        if (new_path or 
700
 
                            self.work_tree.branch.repository._format.rich_root_data):
701
 
                            # Don't report on changes to '' in non rich root
702
 
                            # repositories.
703
 
                            reporter.snapshot_change('modified', new_path)
704
 
            self._next_progress_entry()
705
 
        # Unversion IDs that were found to be deleted
706
 
        self.deleted_ids = deleted_ids
707
 
 
708
 
    def _record_unselected(self):
 
636
        # Check and warn about old CommitBuilders
 
637
        if not self.builder.record_root_entry:
 
638
            symbol_versioning.warn('CommitBuilders should support recording'
 
639
                ' the root entry as of bzr 0.10.', DeprecationWarning, 
 
640
                stacklevel=1)
 
641
            self.builder.new_inventory.add(self.basis_inv.root.copy())
 
642
 
 
643
        # Build the new inventory
 
644
        self._populate_from_inventory(specific_files)
 
645
 
709
646
        # If specific files are selected, then all un-selected files must be
710
647
        # recorded in their previous state. For more details, see
711
648
        # https://lists.ubuntu.com/archives/bazaar/2007q3/028476.html.
712
 
        if self.specific_files or self.exclude:
713
 
            specific_files = self.specific_files or []
 
649
        if specific_files:
714
650
            for path, old_ie in self.basis_inv.iter_entries():
715
651
                if old_ie.file_id in self.builder.new_inventory:
716
652
                    # already added - skip.
717
653
                    continue
718
 
                if (is_inside_any(specific_files, path)
719
 
                    and not is_inside_any(self.exclude, path)):
720
 
                    # was inside the selected path, and not excluded - if not
721
 
                    # present it has been deleted so skip.
 
654
                if is_inside_any(specific_files, path):
 
655
                    # was inside the selected path, if not present it has been
 
656
                    # deleted so skip.
722
657
                    continue
723
 
                # From here down it was either not selected, or was excluded:
724
 
                # We preserve the entry unaltered.
 
658
                if old_ie.kind == 'directory':
 
659
                    self._next_progress_entry()
 
660
                # not in final inv yet, was not in the selected files, so is an
 
661
                # entry to be preserved unaltered.
725
662
                ie = old_ie.copy()
726
663
                # Note: specific file commits after a merge are currently
727
664
                # prohibited. This test is for sanity/safety in case it's
728
665
                # required after that changes.
729
666
                if len(self.parents) > 1:
730
667
                    ie.revision = None
731
 
                self.builder.record_entry_contents(ie, self.parent_invs, path,
732
 
                    self.basis_tree, None)
 
668
                delta, version_recorded = self.builder.record_entry_contents(
 
669
                    ie, self.parent_invs, path, self.basis_tree, None)
 
670
                if version_recorded:
 
671
                    self.any_entries_changed = True
733
672
 
734
 
    def _report_and_accumulate_deletes(self):
735
 
        if (isinstance(self.basis_inv, Inventory)
736
 
            and isinstance(self.builder.new_inventory, Inventory)):
737
 
            # the older Inventory classes provide a _byid dict, and building a
738
 
            # set from the keys of this dict is substantially faster than even
739
 
            # getting a set of ids from the inventory
740
 
            #
741
 
            # <lifeless> set(dict) is roughly the same speed as
742
 
            # set(iter(dict)) and both are significantly slower than
743
 
            # set(dict.keys())
744
 
            deleted_ids = set(self.basis_inv._byid.keys()) - \
745
 
               set(self.builder.new_inventory._byid.keys())
746
 
        else:
747
 
            deleted_ids = set(self.basis_inv) - set(self.builder.new_inventory)
748
 
        if deleted_ids:
 
673
        # note that deletes have occurred
 
674
        if set(self.basis_inv._byid.keys()) - set(self.builder.new_inventory._byid.keys()):
749
675
            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()
753
 
            # XXX: this is not quite directory-order sorting
754
 
            for path, file_id in deleted:
755
 
                self.builder.record_delete(path, file_id)
756
 
                self.reporter.deleted(path)
 
676
        # Report what was deleted.
 
677
        if self.any_entries_deleted and self.reporter.is_verbose():
 
678
            for path, ie in self.basis_inv.iter_entries():
 
679
                if ie.file_id not in self.builder.new_inventory:
 
680
                    self.reporter.deleted(path)
757
681
 
758
 
    def _check_strict(self):
759
 
        # XXX: when we use iter_changes this would likely be faster if
760
 
        # iter_changes would check for us (even in the presence of
761
 
        # selected_files).
 
682
    def _populate_from_inventory(self, specific_files):
 
683
        """Populate the CommitBuilder by walking the working tree inventory."""
762
684
        if self.strict:
763
685
            # raise an exception as soon as we find a single unknown.
764
686
            for unknown in self.work_tree.unknowns():
765
687
                raise StrictCommitFailed()
766
 
 
767
 
    def _populate_from_inventory(self):
768
 
        """Populate the CommitBuilder by walking the working tree inventory."""
769
 
        # Build the revision inventory.
770
 
        #
771
 
        # This starts by creating a new empty inventory. Depending on
772
 
        # which files are selected for commit, and what is present in the
773
 
        # current tree, the new inventory is populated. inventory entries
774
 
        # which are candidates for modification have their revision set to
775
 
        # None; inventory entries that are carried over untouched have their
776
 
        # revision set to their prior value.
777
 
        #
778
 
        # ESEPARATIONOFCONCERNS: this function is diffing and using the diff
779
 
        # results to create a new inventory at the same time, which results
780
 
        # in bugs like #46635.  Any reason not to use/enhance Tree.changes_from?
781
 
        # ADHB 11-07-2006
782
 
 
783
 
        specific_files = self.specific_files
784
 
        exclude = self.exclude
 
688
               
785
689
        report_changes = self.reporter.is_verbose()
786
690
        deleted_ids = []
787
 
        # A tree of paths that have been deleted. E.g. if foo/bar has been
788
 
        # deleted, then we have {'foo':{'bar':{}}}
789
 
        deleted_paths = {}
790
 
        # XXX: Note that entries may have the wrong kind because the entry does
791
 
        # not reflect the status on disk.
 
691
        deleted_paths = set()
792
692
        work_inv = self.work_tree.inventory
793
 
        # NB: entries will include entries within the excluded ids/paths
794
 
        # because iter_entries_by_dir has no 'exclude' facility today.
 
693
        assert work_inv.root is not None
 
694
        # XXX: Note that entries may have the wrong kind.
795
695
        entries = work_inv.iter_entries_by_dir(
796
696
            specific_file_ids=self.specific_file_ids, yield_parents=True)
 
697
        if not self.builder.record_root_entry:
 
698
            entries.next()
797
699
        for path, existing_ie in entries:
798
700
            file_id = existing_ie.file_id
799
701
            name = existing_ie.name
800
702
            parent_id = existing_ie.parent_id
801
703
            kind = existing_ie.kind
 
704
            if kind == 'directory':
 
705
                self._next_progress_entry()
802
706
            # Skip files that have been deleted from the working tree.
803
 
            # The deleted path ids are also recorded so they can be explicitly
804
 
            # unversioned later.
805
 
            if deleted_paths:
806
 
                path_segments = splitpath(path)
807
 
                deleted_dict = deleted_paths
808
 
                for segment in path_segments:
809
 
                    deleted_dict = deleted_dict.get(segment, None)
810
 
                    if not deleted_dict:
811
 
                        # We either took a path not present in the dict
812
 
                        # (deleted_dict was None), or we've reached an empty
813
 
                        # child dir in the dict, so are now a sub-path.
814
 
                        break
815
 
                else:
816
 
                    deleted_dict = None
817
 
                if deleted_dict is not None:
818
 
                    # the path has a deleted parent, do not add it.
819
 
                    continue
820
 
            if exclude and is_inside_any(exclude, path):
821
 
                # Skip excluded paths. Excluded paths are processed by
822
 
                # _update_builder_with_changes.
 
707
            # The deleted files/directories are also recorded so they
 
708
            # can be explicitly unversioned later. Note that when a
 
709
            # filter of specific files is given, we must only skip/record
 
710
            # deleted files matching that filter.
 
711
            if is_inside_any(deleted_paths, path):
823
712
                continue
824
713
            content_summary = self.work_tree.path_content_summary(path)
825
 
            kind = content_summary[0]
826
 
            # Note that when a filter of specific files is given, we must only
827
 
            # skip/record deleted files matching that filter.
828
714
            if not specific_files or is_inside_any(specific_files, path):
829
 
                if kind == 'missing':
830
 
                    if not deleted_paths:
831
 
                        # path won't have been split yet.
832
 
                        path_segments = splitpath(path)
833
 
                    deleted_dict = deleted_paths
834
 
                    for segment in path_segments:
835
 
                        deleted_dict = deleted_dict.setdefault(segment, {})
 
715
                if content_summary[0] == 'missing':
 
716
                    deleted_paths.add(path)
836
717
                    self.reporter.missing(path)
837
 
                    self._next_progress_entry()
838
718
                    deleted_ids.append(file_id)
839
719
                    continue
840
720
            # TODO: have the builder do the nested commit just-in-time IF and
841
721
            # only if needed.
842
 
            if kind == 'tree-reference':
 
722
            if content_summary[0] == 'tree-reference':
843
723
                # enforce repository nested tree policy.
844
724
                if (not self.work_tree.supports_tree_reference() or
845
725
                    # repository does not support it either.
846
726
                    not self.branch.repository._format.supports_tree_reference):
847
 
                    kind = 'directory'
848
 
                    content_summary = (kind, None, None, None)
849
 
                elif self.recursive == 'down':
 
727
                    content_summary = ('directory',) + content_summary[1:]
 
728
            kind = content_summary[0]
 
729
            # TODO: specific_files filtering before nested tree processing
 
730
            if kind == 'tree-reference':
 
731
                if self.recursive == 'down':
850
732
                    nested_revision_id = self._commit_nested_tree(
851
733
                        file_id, path)
852
 
                    content_summary = (kind, None, None, nested_revision_id)
 
734
                    content_summary = content_summary[:3] + (
 
735
                        nested_revision_id,)
853
736
                else:
854
 
                    nested_revision_id = self.work_tree.get_reference_revision(file_id)
855
 
                    content_summary = (kind, None, None, nested_revision_id)
 
737
                    content_summary = content_summary[:3] + (
 
738
                        self.work_tree.get_reference_revision(file_id),)
856
739
 
857
740
            # Record an entry for this item
858
741
            # Note: I don't particularly want to have the existing_ie
864
747
                content_summary)
865
748
 
866
749
        # Unversion IDs that were found to be deleted
867
 
        self.deleted_ids = deleted_ids
 
750
        self.work_tree.unversion(deleted_ids)
868
751
 
869
752
    def _commit_nested_tree(self, file_id, path):
870
753
        "Commit a nested tree."
872
755
        # FIXME: be more comprehensive here:
873
756
        # this works when both trees are in --trees repository,
874
757
        # but when both are bound to a different repository,
875
 
        # it fails; a better way of approaching this is to
 
758
        # it fails; a better way of approaching this is to 
876
759
        # finally implement the explicit-caches approach design
877
760
        # a while back - RBC 20070306.
878
761
        if sub_tree.branch.repository.has_same_location(
898
781
        # mutter('check %s {%s}', path, file_id)
899
782
        # mutter('%s selected for commit', path)
900
783
        if definitely_changed or existing_ie is None:
901
 
            ie = make_entry(kind, name, parent_id, file_id)
 
784
            ie = inventory.make_entry(kind, name, parent_id, file_id)
902
785
        else:
903
786
            ie = existing_ie.copy()
904
787
            ie.revision = None
905
 
        # For carried over entries we don't care about the fs hash - the repo
906
 
        # isn't generating a sha, so we're not saving computation time.
907
 
        _, _, fs_hash = self.builder.record_entry_contents(
908
 
            ie, self.parent_invs, path, self.work_tree, content_summary)
 
788
        delta, version_recorded = self.builder.record_entry_contents(ie,
 
789
            self.parent_invs, path, self.work_tree, content_summary)
 
790
        if version_recorded:
 
791
            self.any_entries_changed = True
909
792
        if report_changes:
910
793
            self._report_change(ie, path)
911
 
        if fs_hash:
912
 
            self.work_tree._observed_sha1(ie.file_id, path, fs_hash)
913
794
        return ie
914
795
 
915
796
    def _report_change(self, ie, path):
923
804
        else:
924
805
            basis_ie = None
925
806
        change = ie.describe_change(basis_ie, ie)
926
 
        if change in (InventoryEntry.RENAMED,
 
807
        if change in (InventoryEntry.RENAMED, 
927
808
            InventoryEntry.MODIFIED_AND_RENAMED):
928
809
            old_path = self.basis_inv.id2path(ie.file_id)
929
810
            self.reporter.renamed(change, old_path, path)
930
 
            self._next_progress_entry()
931
811
        else:
932
 
            if change == 'unchanged':
933
 
                return
934
812
            self.reporter.snapshot_change(change, path)
935
 
            self._next_progress_entry()
936
813
 
937
 
    def _set_progress_stage(self, name, counter=False):
 
814
    def _set_progress_stage(self, name, entries_title=None):
938
815
        """Set the progress stage and emit an update to the progress bar."""
939
816
        self.pb_stage_name = name
940
817
        self.pb_stage_count += 1
941
 
        if counter:
 
818
        self.pb_entries_title = entries_title
 
819
        if entries_title is not None:
942
820
            self.pb_entries_count = 0
943
 
        else:
944
 
            self.pb_entries_count = None
 
821
            self.pb_entries_total = '?'
945
822
        self._emit_progress()
946
823
 
947
824
    def _next_progress_entry(self):
950
827
        self._emit_progress()
951
828
 
952
829
    def _emit_progress(self):
953
 
        if self.pb_entries_count is not None:
954
 
            text = "%s [%d] - Stage" % (self.pb_stage_name,
955
 
                self.pb_entries_count)
 
830
        if self.pb_entries_title:
 
831
            if self.pb_entries_total == '?':
 
832
                text = "%s [%s %d] - Stage" % (self.pb_stage_name,
 
833
                    self.pb_entries_title, self.pb_entries_count)
 
834
            else:
 
835
                text = "%s [%s %d/%s] - Stage" % (self.pb_stage_name,
 
836
                    self.pb_entries_title, self.pb_entries_count,
 
837
                    str(self.pb_entries_total))
956
838
        else:
957
 
            text = "%s - Stage" % (self.pb_stage_name, )
 
839
            text = "%s - Stage" % (self.pb_stage_name)
958
840
        self.pb.update(text, self.pb_stage_count, self.pb_stage_total)
959
841
 
960
 
    def _set_specific_file_ids(self):
961
 
        """populate self.specific_file_ids if we will use it."""
962
 
        if not self.use_record_iter_changes:
963
 
            # If provided, ensure the specified files are versioned
964
 
            if self.specific_files is not None:
965
 
                # Note: This routine is being called because it raises
966
 
                # PathNotVersionedError as a side effect of finding the IDs. We
967
 
                # later use the ids we found as input to the working tree
968
 
                # inventory iterator, so we only consider those ids rather than
969
 
                # examining the whole tree again.
970
 
                # XXX: Dont we have filter_unversioned to do this more
971
 
                # cheaply?
972
 
                self.specific_file_ids = tree.find_ids_across_trees(
973
 
                    self.specific_files, [self.basis_tree, self.work_tree])
974
 
            else:
975
 
                self.specific_file_ids = None