~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-06-20 01:09:18 UTC
  • mfrom: (3505.1.1 ianc-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080620010918-64z4xylh1ap5hgyf
Accept user names with @s in URLs (Neil Martinsen-Burrell)

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
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
 
20
# working tree and that were in the predecessor are reported as
 
21
# removed --- this can include files that were either removed from the
 
22
# inventory or deleted in the working tree.  If they were only
 
23
# deleted from disk, they are removed from the working inventory.
 
24
 
 
25
# We then consider the remaining entries, which will be in the new
 
26
# version.  Directory entries are simply copied across.  File entries
 
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
 
29
# version of the file was present.  If the file was present in at
 
30
# least one tree, and if it was the same version in all the trees,
 
31
# then we can just refer to that version.  Otherwise, a new version
 
32
# representing the merger of the file versions must be added.
 
33
 
 
34
# TODO: Update hashcache before and after - or does the WorkingTree
 
35
# look after that?
 
36
 
 
37
# TODO: Rather than mashing together the ancestry and storing it back,
 
38
# perhaps the weave should have single method which does it all in one
 
39
# go, avoiding a lot of redundant work.
 
40
 
 
41
# TODO: Perhaps give a warning if one of the revisions marked as
 
42
# merged is already in the ancestry, and then don't record it as a
 
43
# distinct parent.
 
44
 
 
45
# TODO: If the file is newly merged but unchanged from the version it
 
46
# merges from, then it should still be reported as newly added
 
47
# relative to the basis revision.
 
48
 
 
49
# TODO: Change the parameter 'rev_id' to 'revision_id' to be consistent with
 
50
# the rest of the code; add a deprecation of the old name.
 
51
 
 
52
import os
 
53
import re
 
54
import sys
 
55
import time
 
56
 
 
57
from cStringIO import StringIO
 
58
 
 
59
from bzrlib import (
 
60
    debug,
 
61
    errors,
 
62
    revision,
 
63
    tree,
 
64
    )
 
65
from bzrlib.branch import Branch
 
66
import bzrlib.config
 
67
from bzrlib.errors import (BzrError, PointlessCommit,
 
68
                           ConflictsInTree,
 
69
                           StrictCommitFailed
 
70
                           )
 
71
from bzrlib.osutils import (kind_marker, isdir,isfile, is_inside_any,
 
72
                            is_inside_or_parent_of_any,
 
73
                            minimum_path_selection,
 
74
                            quotefn, sha_file, split_lines,
 
75
                            splitpath,
 
76
                            )
 
77
from bzrlib.testament import Testament
 
78
from bzrlib.trace import mutter, note, warning, is_quiet
 
79
from bzrlib.xml5 import serializer_v5
 
80
from bzrlib.inventory import InventoryEntry, make_entry
 
81
from bzrlib import symbol_versioning
 
82
from bzrlib.symbol_versioning import (deprecated_passed,
 
83
        deprecated_function,
 
84
        DEPRECATED_PARAMETER)
 
85
from bzrlib.workingtree import WorkingTree
 
86
from bzrlib.urlutils import unescape_for_display
 
87
import bzrlib.ui
 
88
 
 
89
 
 
90
class NullCommitReporter(object):
 
91
    """I report on progress of a commit."""
 
92
 
 
93
    def started(self, revno, revid, location=None):
 
94
        if location is None:
 
95
            symbol_versioning.warn("As of bzr 1.0 you must pass a location "
 
96
                                   "to started.", DeprecationWarning,
 
97
                                   stacklevel=2)
 
98
        pass
 
99
 
 
100
    def snapshot_change(self, change, path):
 
101
        pass
 
102
 
 
103
    def completed(self, revno, rev_id):
 
104
        pass
 
105
 
 
106
    def deleted(self, file_id):
 
107
        pass
 
108
 
 
109
    def escaped(self, escape_count, message):
 
110
        pass
 
111
 
 
112
    def missing(self, path):
 
113
        pass
 
114
 
 
115
    def renamed(self, change, old_path, new_path):
 
116
        pass
 
117
 
 
118
    def is_verbose(self):
 
119
        return False
 
120
 
 
121
 
 
122
class ReportCommitToLog(NullCommitReporter):
 
123
 
 
124
    def _note(self, format, *args):
 
125
        """Output a message.
 
126
 
 
127
        Subclasses may choose to override this method.
 
128
        """
 
129
        note(format, *args)
 
130
 
 
131
    def snapshot_change(self, change, path):
 
132
        if change == 'unchanged':
 
133
            return
 
134
        if change == 'added' and path == '':
 
135
            return
 
136
        self._note("%s %s", change, path)
 
137
 
 
138
    def started(self, revno, rev_id, location=None):
 
139
        if location is not None:
 
140
            location = ' to: ' + unescape_for_display(location, 'utf-8')
 
141
        else:
 
142
            # When started was added, location was only made optional by
 
143
            # accident.  Matt Nordhoff 20071129
 
144
            symbol_versioning.warn("As of bzr 1.0 you must pass a location "
 
145
                                   "to started.", DeprecationWarning,
 
146
                                   stacklevel=2)
 
147
            location = ''
 
148
        self._note('Committing%s', location)
 
149
 
 
150
    def completed(self, revno, rev_id):
 
151
        self._note('Committed revision %d.', revno)
 
152
 
 
153
    def deleted(self, file_id):
 
154
        self._note('deleted %s', file_id)
 
155
 
 
156
    def escaped(self, escape_count, message):
 
157
        self._note("replaced %d control characters in message", escape_count)
 
158
 
 
159
    def missing(self, path):
 
160
        self._note('missing %s', path)
 
161
 
 
162
    def renamed(self, change, old_path, new_path):
 
163
        self._note('%s %s => %s', change, old_path, new_path)
 
164
 
 
165
    def is_verbose(self):
 
166
        return True
 
167
 
 
168
 
 
169
class Commit(object):
 
170
    """Task of committing a new revision.
 
171
 
 
172
    This is a MethodObject: it accumulates state as the commit is
 
173
    prepared, and then it is discarded.  It doesn't represent
 
174
    historical revisions, just the act of recording a new one.
 
175
 
 
176
            missing_ids
 
177
            Modified to hold a list of files that have been deleted from
 
178
            the working directory; these should be removed from the
 
179
            working inventory.
 
180
    """
 
181
    def __init__(self,
 
182
                 reporter=None,
 
183
                 config=None):
 
184
        """Create a Commit object.
 
185
 
 
186
        :param reporter: the default reporter to use or None to decide later
 
187
        """
 
188
        self.reporter = reporter
 
189
        self.config = config
 
190
 
 
191
    def commit(self,
 
192
               message=None,
 
193
               timestamp=None,
 
194
               timezone=None,
 
195
               committer=None,
 
196
               specific_files=None,
 
197
               rev_id=None,
 
198
               allow_pointless=True,
 
199
               strict=False,
 
200
               verbose=False,
 
201
               revprops=None,
 
202
               working_tree=None,
 
203
               local=False,
 
204
               reporter=None,
 
205
               config=None,
 
206
               message_callback=None,
 
207
               recursive='down'):
 
208
        """Commit working copy as a new revision.
 
209
 
 
210
        :param message: the commit message (it or message_callback is required)
 
211
 
 
212
        :param timestamp: if not None, seconds-since-epoch for a
 
213
            postdated/predated commit.
 
214
 
 
215
        :param specific_files: If true, commit only those files.
 
216
 
 
217
        :param rev_id: If set, use this as the new revision id.
 
218
            Useful for test or import commands that need to tightly
 
219
            control what revisions are assigned.  If you duplicate
 
220
            a revision id that exists elsewhere it is your own fault.
 
221
            If null (default), a time/random revision id is generated.
 
222
 
 
223
        :param allow_pointless: If true (default), commit even if nothing
 
224
            has changed and no merges are recorded.
 
225
 
 
226
        :param strict: If true, don't allow a commit if the working tree
 
227
            contains unknown files.
 
228
 
 
229
        :param revprops: Properties for new revision
 
230
        :param local: Perform a local only commit.
 
231
        :param reporter: the reporter to use or None for the default
 
232
        :param verbose: if True and the reporter is not None, report everything
 
233
        :param recursive: If set to 'down', commit in any subtrees that have
 
234
            pending changes of any sort during this commit.
 
235
        """
 
236
        mutter('preparing to commit')
 
237
 
 
238
        if working_tree is None:
 
239
            raise BzrError("working_tree must be passed into commit().")
 
240
        else:
 
241
            self.work_tree = working_tree
 
242
            self.branch = self.work_tree.branch
 
243
            if getattr(self.work_tree, 'requires_rich_root', lambda: False)():
 
244
                if not self.branch.repository.supports_rich_root():
 
245
                    raise errors.RootNotRich()
 
246
        if message_callback is None:
 
247
            if message is not None:
 
248
                if isinstance(message, str):
 
249
                    message = message.decode(bzrlib.user_encoding)
 
250
                message_callback = lambda x: message
 
251
            else:
 
252
                raise BzrError("The message or message_callback keyword"
 
253
                               " parameter is required for commit().")
 
254
 
 
255
        self.bound_branch = None
 
256
        self.any_entries_changed = False
 
257
        self.any_entries_deleted = False
 
258
        self.local = local
 
259
        self.master_branch = None
 
260
        self.master_locked = False
 
261
        self.recursive = recursive
 
262
        self.rev_id = None
 
263
        if specific_files is not None:
 
264
            self.specific_files = sorted(
 
265
                minimum_path_selection(specific_files))
 
266
        else:
 
267
            self.specific_files = None
 
268
        self.specific_file_ids = None
 
269
        self.allow_pointless = allow_pointless
 
270
        self.revprops = revprops
 
271
        self.message_callback = message_callback
 
272
        self.timestamp = timestamp
 
273
        self.timezone = timezone
 
274
        self.committer = committer
 
275
        self.strict = strict
 
276
        self.verbose = verbose
 
277
        # accumulates an inventory delta to the basis entry, so we can make
 
278
        # just the necessary updates to the workingtree's cached basis.
 
279
        self._basis_delta = []
 
280
 
 
281
        self.work_tree.lock_write()
 
282
        self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
283
        self.basis_revid = self.work_tree.last_revision()
 
284
        self.basis_tree = self.work_tree.basis_tree()
 
285
        self.basis_tree.lock_read()
 
286
        try:
 
287
            # Cannot commit with conflicts present.
 
288
            if len(self.work_tree.conflicts()) > 0:
 
289
                raise ConflictsInTree
 
290
 
 
291
            # Setup the bound branch variables as needed.
 
292
            self._check_bound_branch()
 
293
 
 
294
            # Check that the working tree is up to date
 
295
            old_revno, new_revno = self._check_out_of_date_tree()
 
296
 
 
297
            # Complete configuration setup
 
298
            if reporter is not None:
 
299
                self.reporter = reporter
 
300
            elif self.reporter is None:
 
301
                self.reporter = self._select_reporter()
 
302
            if self.config is None:
 
303
                self.config = self.branch.get_config()
 
304
 
 
305
            # If provided, ensure the specified files are versioned
 
306
            if self.specific_files is not None:
 
307
                # Note: This routine is being called because it raises
 
308
                # PathNotVersionedError as a side effect of finding the IDs. We
 
309
                # later use the ids we found as input to the working tree
 
310
                # inventory iterator, so we only consider those ids rather than
 
311
                # examining the whole tree again.
 
312
                # XXX: Dont we have filter_unversioned to do this more
 
313
                # cheaply?
 
314
                self.specific_file_ids = tree.find_ids_across_trees(
 
315
                    specific_files, [self.basis_tree, self.work_tree])
 
316
 
 
317
            # Setup the progress bar. As the number of files that need to be
 
318
            # committed in unknown, progress is reported as stages.
 
319
            # We keep track of entries separately though and include that
 
320
            # information in the progress bar during the relevant stages.
 
321
            self.pb_stage_name = ""
 
322
            self.pb_stage_count = 0
 
323
            self.pb_stage_total = 5
 
324
            if self.bound_branch:
 
325
                self.pb_stage_total += 1
 
326
            self.pb.show_pct = False
 
327
            self.pb.show_spinner = False
 
328
            self.pb.show_eta = False
 
329
            self.pb.show_count = True
 
330
            self.pb.show_bar = True
 
331
 
 
332
            # After a merge, a selected file commit is not supported.
 
333
            # See 'bzr help merge' for an explanation as to why.
 
334
            self.basis_inv = self.basis_tree.inventory
 
335
            self._gather_parents()
 
336
            if len(self.parents) > 1 and self.specific_files:
 
337
                raise errors.CannotCommitSelectedFileMerge(self.specific_files)
 
338
 
 
339
            # Collect the changes
 
340
            self._set_progress_stage("Collecting changes",
 
341
                    entries_title="Directory")
 
342
            self.builder = self.branch.get_commit_builder(self.parents,
 
343
                self.config, timestamp, timezone, committer, revprops, rev_id)
 
344
            
 
345
            try:
 
346
                # find the location being committed to
 
347
                if self.bound_branch:
 
348
                    master_location = self.master_branch.base
 
349
                else:
 
350
                    master_location = self.branch.base
 
351
 
 
352
                # report the start of the commit
 
353
                self.reporter.started(new_revno, self.rev_id, master_location)
 
354
 
 
355
                self._update_builder_with_changes()
 
356
                self._report_and_accumulate_deletes()
 
357
                self._check_pointless()
 
358
 
 
359
                # TODO: Now the new inventory is known, check for conflicts.
 
360
                # ADHB 2006-08-08: If this is done, populate_new_inv should not add
 
361
                # weave lines, because nothing should be recorded until it is known
 
362
                # that commit will succeed.
 
363
                self._set_progress_stage("Saving data locally")
 
364
                self.builder.finish_inventory()
 
365
 
 
366
                # Prompt the user for a commit message if none provided
 
367
                message = message_callback(self)
 
368
                self.message = message
 
369
                self._escape_commit_message()
 
370
 
 
371
                # Add revision data to the local branch
 
372
                self.rev_id = self.builder.commit(self.message)
 
373
 
 
374
            except:
 
375
                self.builder.abort()
 
376
                raise
 
377
 
 
378
            self._process_pre_hooks(old_revno, new_revno)
 
379
 
 
380
            # Upload revision data to the master.
 
381
            # this will propagate merged revisions too if needed.
 
382
            if self.bound_branch:
 
383
                if not self.master_branch.repository.has_same_location(
 
384
                        self.branch.repository):
 
385
                    self._set_progress_stage("Uploading data to master branch")
 
386
                    self.master_branch.repository.fetch(self.branch.repository,
 
387
                        revision_id=self.rev_id)
 
388
                # now the master has the revision data
 
389
                # 'commit' to the master first so a timeout here causes the
 
390
                # local branch to be out of date
 
391
                self.master_branch.set_last_revision_info(new_revno,
 
392
                                                          self.rev_id)
 
393
 
 
394
            # and now do the commit locally.
 
395
            self.branch.set_last_revision_info(new_revno, self.rev_id)
 
396
 
 
397
            # Make the working tree up to date with the branch
 
398
            self._set_progress_stage("Updating the working tree")
 
399
            self.work_tree.update_basis_by_delta(self.rev_id,
 
400
                 self._basis_delta)
 
401
            self.reporter.completed(new_revno, self.rev_id)
 
402
            self._process_post_hooks(old_revno, new_revno)
 
403
        finally:
 
404
            self._cleanup()
 
405
        return self.rev_id
 
406
 
 
407
    def _select_reporter(self):
 
408
        """Select the CommitReporter to use."""
 
409
        if is_quiet():
 
410
            return NullCommitReporter()
 
411
        return ReportCommitToLog()
 
412
 
 
413
    def _check_pointless(self):
 
414
        if self.allow_pointless:
 
415
            return
 
416
        # A merge with no effect on files
 
417
        if len(self.parents) > 1:
 
418
            return
 
419
        # TODO: we could simplify this by using self._basis_delta.
 
420
 
 
421
        # The initial commit adds a root directory, but this in itself is not
 
422
        # a worthwhile commit.
 
423
        if (self.basis_revid == revision.NULL_REVISION and
 
424
            len(self.builder.new_inventory) == 1):
 
425
            raise PointlessCommit()
 
426
        # If length == 1, then we only have the root entry. Which means
 
427
        # that there is no real difference (only the root could be different)
 
428
        # unless deletes occured, in which case the length is irrelevant.
 
429
        if (self.any_entries_deleted or 
 
430
            (len(self.builder.new_inventory) != 1 and
 
431
             self.any_entries_changed)):
 
432
            return
 
433
        raise PointlessCommit()
 
434
 
 
435
    def _check_bound_branch(self):
 
436
        """Check to see if the local branch is bound.
 
437
 
 
438
        If it is bound, then most of the commit will actually be
 
439
        done using the remote branch as the target branch.
 
440
        Only at the end will the local branch be updated.
 
441
        """
 
442
        if self.local and not self.branch.get_bound_location():
 
443
            raise errors.LocalRequiresBoundBranch()
 
444
 
 
445
        if not self.local:
 
446
            self.master_branch = self.branch.get_master_branch()
 
447
 
 
448
        if not self.master_branch:
 
449
            # make this branch the reference branch for out of date checks.
 
450
            self.master_branch = self.branch
 
451
            return
 
452
 
 
453
        # If the master branch is bound, we must fail
 
454
        master_bound_location = self.master_branch.get_bound_location()
 
455
        if master_bound_location:
 
456
            raise errors.CommitToDoubleBoundBranch(self.branch,
 
457
                    self.master_branch, master_bound_location)
 
458
 
 
459
        # TODO: jam 20051230 We could automatically push local
 
460
        #       commits to the remote branch if they would fit.
 
461
        #       But for now, just require remote to be identical
 
462
        #       to local.
 
463
        
 
464
        # Make sure the local branch is identical to the master
 
465
        master_info = self.master_branch.last_revision_info()
 
466
        local_info = self.branch.last_revision_info()
 
467
        if local_info != master_info:
 
468
            raise errors.BoundBranchOutOfDate(self.branch,
 
469
                    self.master_branch)
 
470
 
 
471
        # Now things are ready to change the master branch
 
472
        # so grab the lock
 
473
        self.bound_branch = self.branch
 
474
        self.master_branch.lock_write()
 
475
        self.master_locked = True
 
476
 
 
477
    def _check_out_of_date_tree(self):
 
478
        """Check that the working tree is up to date.
 
479
 
 
480
        :return: old_revision_number,new_revision_number tuple
 
481
        """
 
482
        try:
 
483
            first_tree_parent = self.work_tree.get_parent_ids()[0]
 
484
        except IndexError:
 
485
            # if there are no parents, treat our parent as 'None'
 
486
            # this is so that we still consider the master branch
 
487
            # - in a checkout scenario the tree may have no
 
488
            # parents but the branch may do.
 
489
            first_tree_parent = bzrlib.revision.NULL_REVISION
 
490
        old_revno, master_last = self.master_branch.last_revision_info()
 
491
        if master_last != first_tree_parent:
 
492
            if master_last != bzrlib.revision.NULL_REVISION:
 
493
                raise errors.OutOfDateTree(self.work_tree)
 
494
        if self.branch.repository.has_revision(first_tree_parent):
 
495
            new_revno = old_revno + 1
 
496
        else:
 
497
            # ghost parents never appear in revision history.
 
498
            new_revno = 1
 
499
        return old_revno,new_revno
 
500
 
 
501
    def _process_pre_hooks(self, old_revno, new_revno):
 
502
        """Process any registered pre commit hooks."""
 
503
        self._set_progress_stage("Running pre_commit hooks")
 
504
        self._process_hooks("pre_commit", old_revno, new_revno)
 
505
 
 
506
    def _process_post_hooks(self, old_revno, new_revno):
 
507
        """Process any registered post commit hooks."""
 
508
        # Process the post commit hooks, if any
 
509
        self._set_progress_stage("Running post_commit hooks")
 
510
        # old style commit hooks - should be deprecated ? (obsoleted in
 
511
        # 0.15)
 
512
        if self.config.post_commit() is not None:
 
513
            hooks = self.config.post_commit().split(' ')
 
514
            # this would be nicer with twisted.python.reflect.namedAny
 
515
            for hook in hooks:
 
516
                result = eval(hook + '(branch, rev_id)',
 
517
                              {'branch':self.branch,
 
518
                               'bzrlib':bzrlib,
 
519
                               'rev_id':self.rev_id})
 
520
        # process new style post commit hooks
 
521
        self._process_hooks("post_commit", old_revno, new_revno)
 
522
 
 
523
    def _process_hooks(self, hook_name, old_revno, new_revno):
 
524
        if not Branch.hooks[hook_name]:
 
525
            return
 
526
        
 
527
        # new style commit hooks:
 
528
        if not self.bound_branch:
 
529
            hook_master = self.branch
 
530
            hook_local = None
 
531
        else:
 
532
            hook_master = self.master_branch
 
533
            hook_local = self.branch
 
534
        # With bound branches, when the master is behind the local branch,
 
535
        # the 'old_revno' and old_revid values here are incorrect.
 
536
        # XXX: FIXME ^. RBC 20060206
 
537
        if self.parents:
 
538
            old_revid = self.parents[0]
 
539
        else:
 
540
            old_revid = bzrlib.revision.NULL_REVISION
 
541
        
 
542
        if hook_name == "pre_commit":
 
543
            future_tree = self.builder.revision_tree()
 
544
            tree_delta = future_tree.changes_from(self.basis_tree,
 
545
                                             include_root=True)
 
546
        
 
547
        for hook in Branch.hooks[hook_name]:
 
548
            # show the running hook in the progress bar. As hooks may
 
549
            # end up doing nothing (e.g. because they are not configured by
 
550
            # the user) this is still showing progress, not showing overall
 
551
            # actions - its up to each plugin to show a UI if it want's to
 
552
            # (such as 'Emailing diff to foo@example.com').
 
553
            self.pb_stage_name = "Running %s hooks [%s]" % \
 
554
                (hook_name, Branch.hooks.get_hook_name(hook))
 
555
            self._emit_progress()
 
556
            if 'hooks' in debug.debug_flags:
 
557
                mutter("Invoking commit hook: %r", hook)
 
558
            if hook_name == "post_commit":
 
559
                hook(hook_local, hook_master, old_revno, old_revid, new_revno,
 
560
                     self.rev_id)
 
561
            elif hook_name == "pre_commit":
 
562
                hook(hook_local, hook_master,
 
563
                     old_revno, old_revid, new_revno, self.rev_id,
 
564
                     tree_delta, future_tree)
 
565
 
 
566
    def _cleanup(self):
 
567
        """Cleanup any open locks, progress bars etc."""
 
568
        cleanups = [self._cleanup_bound_branch,
 
569
                    self.basis_tree.unlock,
 
570
                    self.work_tree.unlock,
 
571
                    self.pb.finished]
 
572
        found_exception = None
 
573
        for cleanup in cleanups:
 
574
            try:
 
575
                cleanup()
 
576
            # we want every cleanup to run no matter what.
 
577
            # so we have a catchall here, but we will raise the
 
578
            # last encountered exception up the stack: and
 
579
            # typically this will be useful enough.
 
580
            except Exception, e:
 
581
                found_exception = e
 
582
        if found_exception is not None: 
 
583
            # don't do a plan raise, because the last exception may have been
 
584
            # trashed, e is our sure-to-work exception even though it loses the
 
585
            # full traceback. XXX: RBC 20060421 perhaps we could check the
 
586
            # exc_info and if its the same one do a plain raise otherwise 
 
587
            # 'raise e' as we do now.
 
588
            raise e
 
589
 
 
590
    def _cleanup_bound_branch(self):
 
591
        """Executed at the end of a try/finally to cleanup a bound branch.
 
592
 
 
593
        If the branch wasn't bound, this is a no-op.
 
594
        If it was, it resents self.branch to the local branch, instead
 
595
        of being the master.
 
596
        """
 
597
        if not self.bound_branch:
 
598
            return
 
599
        if self.master_locked:
 
600
            self.master_branch.unlock()
 
601
 
 
602
    def _escape_commit_message(self):
 
603
        """Replace xml-incompatible control characters."""
 
604
        # FIXME: RBC 20060419 this should be done by the revision
 
605
        # serialiser not by commit. Then we can also add an unescaper
 
606
        # in the deserializer and start roundtripping revision messages
 
607
        # precisely. See repository_implementations/test_repository.py
 
608
        
 
609
        # Python strings can include characters that can't be
 
610
        # represented in well-formed XML; escape characters that
 
611
        # aren't listed in the XML specification
 
612
        # (http://www.w3.org/TR/REC-xml/#NT-Char).
 
613
        self.message, escape_count = re.subn(
 
614
            u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
 
615
            lambda match: match.group(0).encode('unicode_escape'),
 
616
            self.message)
 
617
        if escape_count:
 
618
            self.reporter.escaped(escape_count, self.message)
 
619
 
 
620
    def _gather_parents(self):
 
621
        """Record the parents of a merge for merge detection."""
 
622
        # TODO: Make sure that this list doesn't contain duplicate 
 
623
        # entries and the order is preserved when doing this.
 
624
        self.parents = self.work_tree.get_parent_ids()
 
625
        self.parent_invs = [self.basis_inv]
 
626
        for revision in self.parents[1:]:
 
627
            if self.branch.repository.has_revision(revision):
 
628
                mutter('commit parent revision {%s}', revision)
 
629
                inventory = self.branch.repository.get_inventory(revision)
 
630
                self.parent_invs.append(inventory)
 
631
            else:
 
632
                mutter('commit parent ghost revision {%s}', revision)
 
633
 
 
634
    def _update_builder_with_changes(self):
 
635
        """Update the commit builder with the data about what has changed.
 
636
        """
 
637
        # Build the revision inventory.
 
638
        #
 
639
        # This starts by creating a new empty inventory. Depending on
 
640
        # which files are selected for commit, and what is present in the
 
641
        # current tree, the new inventory is populated. inventory entries 
 
642
        # which are candidates for modification have their revision set to
 
643
        # None; inventory entries that are carried over untouched have their
 
644
        # revision set to their prior value.
 
645
        #
 
646
        # ESEPARATIONOFCONCERNS: this function is diffing and using the diff
 
647
        # results to create a new inventory at the same time, which results
 
648
        # in bugs like #46635.  Any reason not to use/enhance Tree.changes_from?
 
649
        # ADHB 11-07-2006
 
650
 
 
651
        specific_files = self.specific_files
 
652
        mutter("Selecting files for commit with filter %s", specific_files)
 
653
 
 
654
        # Build the new inventory
 
655
        self._populate_from_inventory(specific_files)
 
656
 
 
657
        # If specific files are selected, then all un-selected files must be
 
658
        # recorded in their previous state. For more details, see
 
659
        # https://lists.ubuntu.com/archives/bazaar/2007q3/028476.html.
 
660
        if specific_files:
 
661
            for path, old_ie in self.basis_inv.iter_entries():
 
662
                if old_ie.file_id in self.builder.new_inventory:
 
663
                    # already added - skip.
 
664
                    continue
 
665
                if is_inside_any(specific_files, path):
 
666
                    # was inside the selected path, if not present it has been
 
667
                    # deleted so skip.
 
668
                    continue
 
669
                if old_ie.kind == 'directory':
 
670
                    self._next_progress_entry()
 
671
                # not in final inv yet, was not in the selected files, so is an
 
672
                # entry to be preserved unaltered.
 
673
                ie = old_ie.copy()
 
674
                # Note: specific file commits after a merge are currently
 
675
                # prohibited. This test is for sanity/safety in case it's
 
676
                # required after that changes.
 
677
                if len(self.parents) > 1:
 
678
                    ie.revision = None
 
679
                delta, version_recorded = self.builder.record_entry_contents(
 
680
                    ie, self.parent_invs, path, self.basis_tree, None)
 
681
                if version_recorded:
 
682
                    self.any_entries_changed = True
 
683
                if delta: self._basis_delta.append(delta)
 
684
 
 
685
    def _report_and_accumulate_deletes(self):
 
686
        # XXX: Could the list of deleted paths and ids be instead taken from
 
687
        # _populate_from_inventory?
 
688
        deleted_ids = set(self.basis_inv._byid.keys()) - \
 
689
            set(self.builder.new_inventory._byid.keys())
 
690
        if deleted_ids:
 
691
            self.any_entries_deleted = True
 
692
            deleted = [(self.basis_tree.id2path(file_id), file_id)
 
693
                for file_id in deleted_ids]
 
694
            deleted.sort()
 
695
            # XXX: this is not quite directory-order sorting
 
696
            for path, file_id in deleted:
 
697
                self._basis_delta.append((path, None, file_id, None))
 
698
                self.reporter.deleted(path)
 
699
 
 
700
    def _populate_from_inventory(self, specific_files):
 
701
        """Populate the CommitBuilder by walking the working tree inventory."""
 
702
        if self.strict:
 
703
            # raise an exception as soon as we find a single unknown.
 
704
            for unknown in self.work_tree.unknowns():
 
705
                raise StrictCommitFailed()
 
706
               
 
707
        report_changes = self.reporter.is_verbose()
 
708
        deleted_ids = []
 
709
        # A tree of paths that have been deleted. E.g. if foo/bar has been
 
710
        # deleted, then we have {'foo':{'bar':{}}}
 
711
        deleted_paths = {}
 
712
        # XXX: Note that entries may have the wrong kind because the entry does
 
713
        # not reflect the status on disk.
 
714
        work_inv = self.work_tree.inventory
 
715
        entries = work_inv.iter_entries_by_dir(
 
716
            specific_file_ids=self.specific_file_ids, yield_parents=True)
 
717
        for path, existing_ie in entries:
 
718
            file_id = existing_ie.file_id
 
719
            name = existing_ie.name
 
720
            parent_id = existing_ie.parent_id
 
721
            kind = existing_ie.kind
 
722
            if kind == 'directory':
 
723
                self._next_progress_entry()
 
724
            # Skip files that have been deleted from the working tree.
 
725
            # The deleted path ids are also recorded so they can be explicitly
 
726
            # unversioned later.
 
727
            if deleted_paths:
 
728
                path_segments = splitpath(path)
 
729
                deleted_dict = deleted_paths
 
730
                for segment in path_segments:
 
731
                    deleted_dict = deleted_dict.get(segment, None)
 
732
                    if not deleted_dict:
 
733
                        # We either took a path not present in the dict
 
734
                        # (deleted_dict was None), or we've reached an empty
 
735
                        # child dir in the dict, so are now a sub-path.
 
736
                        break
 
737
                else:
 
738
                    deleted_dict = None
 
739
                if deleted_dict is not None:
 
740
                    # the path has a deleted parent, do not add it.
 
741
                    continue
 
742
            content_summary = self.work_tree.path_content_summary(path)
 
743
            # Note that when a filter of specific files is given, we must only
 
744
            # skip/record deleted files matching that filter.
 
745
            if not specific_files or is_inside_any(specific_files, path):
 
746
                if content_summary[0] == 'missing':
 
747
                    if not deleted_paths:
 
748
                        # path won't have been split yet.
 
749
                        path_segments = splitpath(path)
 
750
                    deleted_dict = deleted_paths
 
751
                    for segment in path_segments:
 
752
                        deleted_dict = deleted_dict.setdefault(segment, {})
 
753
                    self.reporter.missing(path)
 
754
                    deleted_ids.append(file_id)
 
755
                    continue
 
756
            # TODO: have the builder do the nested commit just-in-time IF and
 
757
            # only if needed.
 
758
            if content_summary[0] == 'tree-reference':
 
759
                # enforce repository nested tree policy.
 
760
                if (not self.work_tree.supports_tree_reference() or
 
761
                    # repository does not support it either.
 
762
                    not self.branch.repository._format.supports_tree_reference):
 
763
                    content_summary = ('directory',) + content_summary[1:]
 
764
            kind = content_summary[0]
 
765
            # TODO: specific_files filtering before nested tree processing
 
766
            if kind == 'tree-reference':
 
767
                if self.recursive == 'down':
 
768
                    nested_revision_id = self._commit_nested_tree(
 
769
                        file_id, path)
 
770
                    content_summary = content_summary[:3] + (
 
771
                        nested_revision_id,)
 
772
                else:
 
773
                    content_summary = content_summary[:3] + (
 
774
                        self.work_tree.get_reference_revision(file_id),)
 
775
 
 
776
            # Record an entry for this item
 
777
            # Note: I don't particularly want to have the existing_ie
 
778
            # parameter but the test suite currently (28-Jun-07) breaks
 
779
            # without it thanks to a unicode normalisation issue. :-(
 
780
            definitely_changed = kind != existing_ie.kind
 
781
            self._record_entry(path, file_id, specific_files, kind, name,
 
782
                parent_id, definitely_changed, existing_ie, report_changes,
 
783
                content_summary)
 
784
 
 
785
        # Unversion IDs that were found to be deleted
 
786
        self.work_tree.unversion(deleted_ids)
 
787
 
 
788
    def _commit_nested_tree(self, file_id, path):
 
789
        "Commit a nested tree."
 
790
        sub_tree = self.work_tree.get_nested_tree(file_id, path)
 
791
        # FIXME: be more comprehensive here:
 
792
        # this works when both trees are in --trees repository,
 
793
        # but when both are bound to a different repository,
 
794
        # it fails; a better way of approaching this is to 
 
795
        # finally implement the explicit-caches approach design
 
796
        # a while back - RBC 20070306.
 
797
        if sub_tree.branch.repository.has_same_location(
 
798
            self.work_tree.branch.repository):
 
799
            sub_tree.branch.repository = \
 
800
                self.work_tree.branch.repository
 
801
        try:
 
802
            return sub_tree.commit(message=None, revprops=self.revprops,
 
803
                recursive=self.recursive,
 
804
                message_callback=self.message_callback,
 
805
                timestamp=self.timestamp, timezone=self.timezone,
 
806
                committer=self.committer,
 
807
                allow_pointless=self.allow_pointless,
 
808
                strict=self.strict, verbose=self.verbose,
 
809
                local=self.local, reporter=self.reporter)
 
810
        except errors.PointlessCommit:
 
811
            return self.work_tree.get_reference_revision(file_id)
 
812
 
 
813
    def _record_entry(self, path, file_id, specific_files, kind, name,
 
814
        parent_id, definitely_changed, existing_ie, report_changes,
 
815
        content_summary):
 
816
        "Record the new inventory entry for a path if any."
 
817
        # mutter('check %s {%s}', path, file_id)
 
818
        # mutter('%s selected for commit', path)
 
819
        if definitely_changed or existing_ie is None:
 
820
            ie = make_entry(kind, name, parent_id, file_id)
 
821
        else:
 
822
            ie = existing_ie.copy()
 
823
            ie.revision = None
 
824
        delta, version_recorded = self.builder.record_entry_contents(ie,
 
825
            self.parent_invs, path, self.work_tree, content_summary)
 
826
        if delta:
 
827
            self._basis_delta.append(delta)
 
828
        if version_recorded:
 
829
            self.any_entries_changed = True
 
830
        if report_changes:
 
831
            self._report_change(ie, path)
 
832
        return ie
 
833
 
 
834
    def _report_change(self, ie, path):
 
835
        """Report a change to the user.
 
836
 
 
837
        The change that has occurred is described relative to the basis
 
838
        inventory.
 
839
        """
 
840
        if (self.basis_inv.has_id(ie.file_id)):
 
841
            basis_ie = self.basis_inv[ie.file_id]
 
842
        else:
 
843
            basis_ie = None
 
844
        change = ie.describe_change(basis_ie, ie)
 
845
        if change in (InventoryEntry.RENAMED, 
 
846
            InventoryEntry.MODIFIED_AND_RENAMED):
 
847
            old_path = self.basis_inv.id2path(ie.file_id)
 
848
            self.reporter.renamed(change, old_path, path)
 
849
        else:
 
850
            self.reporter.snapshot_change(change, path)
 
851
 
 
852
    def _set_progress_stage(self, name, entries_title=None):
 
853
        """Set the progress stage and emit an update to the progress bar."""
 
854
        self.pb_stage_name = name
 
855
        self.pb_stage_count += 1
 
856
        self.pb_entries_title = entries_title
 
857
        if entries_title is not None:
 
858
            self.pb_entries_count = 0
 
859
            self.pb_entries_total = '?'
 
860
        self._emit_progress()
 
861
 
 
862
    def _next_progress_entry(self):
 
863
        """Emit an update to the progress bar and increment the entry count."""
 
864
        self.pb_entries_count += 1
 
865
        self._emit_progress()
 
866
 
 
867
    def _emit_progress(self):
 
868
        if self.pb_entries_title:
 
869
            if self.pb_entries_total == '?':
 
870
                text = "%s [%s %d] - Stage" % (self.pb_stage_name,
 
871
                    self.pb_entries_title, self.pb_entries_count)
 
872
            else:
 
873
                text = "%s [%s %d/%s] - Stage" % (self.pb_stage_name,
 
874
                    self.pb_entries_title, self.pb_entries_count,
 
875
                    str(self.pb_entries_total))
 
876
        else:
 
877
            text = "%s - Stage" % (self.pb_stage_name)
 
878
        self.pb.update(text, self.pb_stage_count, self.pb_stage_total)
 
879