/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

(John Arbash Meinel)  Fix bug #158333,
        make sure that Repository.fetch(self) is properly a no-op for all
        Repository implementations.

Show diffs side-by-side

added added

removed removed

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