~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Ian Clatworthy
  • Date: 2009-01-19 02:24:15 UTC
  • mto: This revision was merged to the branch mainline in revision 3944.
  • Revision ID: ian.clatworthy@canonical.com-20090119022415-mo0mcfeiexfktgwt
apply jam's log --short fix (Ian Clatworthy)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
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
57
from cStringIO import StringIO
73
58
 
74
 
from bzrlib.atomicfile import AtomicFile
 
59
from bzrlib import (
 
60
    debug,
 
61
    errors,
 
62
    revision,
 
63
    trace,
 
64
    tree,
 
65
    )
 
66
from bzrlib.branch import Branch
75
67
import bzrlib.config
76
 
import bzrlib.errors as errors
77
68
from bzrlib.errors import (BzrError, PointlessCommit,
78
 
                           HistoryMissing,
79
69
                           ConflictsInTree,
80
70
                           StrictCommitFailed
81
71
                           )
82
 
from bzrlib.osutils import (kind_marker, isdir,isfile, is_inside_any, 
 
72
from bzrlib.osutils import (get_user_encoding,
 
73
                            kind_marker, isdir,isfile, is_inside_any,
83
74
                            is_inside_or_parent_of_any,
84
 
                            quotefn, sha_file, split_lines)
 
75
                            minimum_path_selection,
 
76
                            quotefn, sha_file, split_lines,
 
77
                            splitpath,
 
78
                            )
85
79
from bzrlib.testament import Testament
86
 
from bzrlib.trace import mutter, note, warning
87
 
from bzrlib.xml5 import serializer_v5
88
 
from bzrlib.inventory import Inventory, ROOT_ID, InventoryEntry
89
 
from bzrlib.symbol_versioning import *
 
80
from bzrlib.trace import mutter, note, warning, is_quiet
 
81
from bzrlib.inventory import Inventory, InventoryEntry, make_entry
 
82
from bzrlib import symbol_versioning
 
83
from bzrlib.symbol_versioning import (deprecated_passed,
 
84
        deprecated_function,
 
85
        DEPRECATED_PARAMETER)
90
86
from bzrlib.workingtree import WorkingTree
91
 
 
92
 
 
93
 
@deprecated_function(zero_seven)
94
 
def commit(*args, **kwargs):
95
 
    """Commit a new revision to a branch.
96
 
 
97
 
    Function-style interface for convenience of old callers.
98
 
 
99
 
    New code should use the Commit class instead.
100
 
    """
101
 
    ## XXX: Remove this in favor of Branch.commit?
102
 
    Commit().commit(*args, **kwargs)
 
87
from bzrlib.urlutils import unescape_for_display
 
88
import bzrlib.ui
103
89
 
104
90
 
105
91
class NullCommitReporter(object):
106
92
    """I report on progress of a commit."""
107
93
 
 
94
    def started(self, revno, revid, location=None):
 
95
        if location is None:
 
96
            symbol_versioning.warn("As of bzr 1.0 you must pass a location "
 
97
                                   "to started.", DeprecationWarning,
 
98
                                   stacklevel=2)
 
99
        pass
 
100
 
108
101
    def snapshot_change(self, change, path):
109
102
        pass
110
103
 
123
116
    def renamed(self, change, old_path, new_path):
124
117
        pass
125
118
 
 
119
    def is_verbose(self):
 
120
        return False
 
121
 
126
122
 
127
123
class ReportCommitToLog(NullCommitReporter):
128
124
 
129
 
    # this may be more useful if 'note' was replaced by an overridable
130
 
    # method on self, which would allow more trivial subclassing.
131
 
    # alternative, a callable could be passed in, allowing really trivial
132
 
    # reuse for some uis. RBC 20060511
 
125
    def _note(self, format, *args):
 
126
        """Output a message.
 
127
 
 
128
        Subclasses may choose to override this method.
 
129
        """
 
130
        note(format, *args)
133
131
 
134
132
    def snapshot_change(self, change, path):
135
133
        if change == 'unchanged':
136
134
            return
137
 
        note("%s %s", change, path)
 
135
        if change == 'added' and path == '':
 
136
            return
 
137
        self._note("%s %s", change, path)
 
138
 
 
139
    def started(self, revno, rev_id, location=None):
 
140
        if location is not None:
 
141
            location = ' to: ' + unescape_for_display(location, 'utf-8')
 
142
        else:
 
143
            # When started was added, location was only made optional by
 
144
            # accident.  Matt Nordhoff 20071129
 
145
            symbol_versioning.warn("As of bzr 1.0 you must pass a location "
 
146
                                   "to started.", DeprecationWarning,
 
147
                                   stacklevel=2)
 
148
            location = ''
 
149
        self._note('Committing%s', location)
138
150
 
139
151
    def completed(self, revno, rev_id):
140
 
        note('Committed revision %d.', revno)
141
 
    
 
152
        self._note('Committed revision %d.', revno)
 
153
 
142
154
    def deleted(self, file_id):
143
 
        note('deleted %s', file_id)
 
155
        self._note('deleted %s', file_id)
144
156
 
145
157
    def escaped(self, escape_count, message):
146
 
        note("replaced %d control characters in message", escape_count)
 
158
        self._note("replaced %d control characters in message", escape_count)
147
159
 
148
160
    def missing(self, path):
149
 
        note('missing %s', path)
 
161
        self._note('missing %s', path)
150
162
 
151
163
    def renamed(self, change, old_path, new_path):
152
 
        note('%s %s => %s', change, old_path, new_path)
 
164
        self._note('%s %s => %s', change, old_path, new_path)
 
165
 
 
166
    def is_verbose(self):
 
167
        return True
153
168
 
154
169
 
155
170
class Commit(object):
167
182
    def __init__(self,
168
183
                 reporter=None,
169
184
                 config=None):
170
 
        if reporter is not None:
171
 
            self.reporter = reporter
172
 
        else:
173
 
            self.reporter = NullCommitReporter()
174
 
        if config is not None:
175
 
            self.config = config
176
 
        else:
177
 
            self.config = None
178
 
        
 
185
        """Create a Commit object.
 
186
 
 
187
        :param reporter: the default reporter to use or None to decide later
 
188
        """
 
189
        self.reporter = reporter
 
190
        self.config = config
 
191
 
179
192
    def commit(self,
180
 
               branch=DEPRECATED_PARAMETER, message=None,
 
193
               message=None,
181
194
               timestamp=None,
182
195
               timezone=None,
183
196
               committer=None,
190
203
               working_tree=None,
191
204
               local=False,
192
205
               reporter=None,
193
 
               config=None):
 
206
               config=None,
 
207
               message_callback=None,
 
208
               recursive='down',
 
209
               exclude=None,
 
210
               possible_master_transports=None):
194
211
        """Commit working copy as a new revision.
195
212
 
196
 
        branch -- the deprecated branch to commit to. New callers should pass in 
197
 
                  working_tree instead
198
 
 
199
 
        message -- the commit message, a mandatory parameter
200
 
 
201
 
        timestamp -- if not None, seconds-since-epoch for a
202
 
             postdated/predated commit.
203
 
 
204
 
        specific_files -- If true, commit only those files.
205
 
 
206
 
        rev_id -- If set, use this as the new revision id.
 
213
        :param message: the commit message (it or message_callback is required)
 
214
 
 
215
        :param timestamp: if not None, seconds-since-epoch for a
 
216
            postdated/predated commit.
 
217
 
 
218
        :param specific_files: If true, commit only those files.
 
219
 
 
220
        :param rev_id: If set, use this as the new revision id.
207
221
            Useful for test or import commands that need to tightly
208
222
            control what revisions are assigned.  If you duplicate
209
223
            a revision id that exists elsewhere it is your own fault.
210
224
            If null (default), a time/random revision id is generated.
211
225
 
212
 
        allow_pointless -- If true (default), commit even if nothing
 
226
        :param allow_pointless: If true (default), commit even if nothing
213
227
            has changed and no merges are recorded.
214
228
 
215
 
        strict -- If true, don't allow a commit if the working tree
 
229
        :param strict: If true, don't allow a commit if the working tree
216
230
            contains unknown files.
217
231
 
218
 
        revprops -- Properties for new revision
 
232
        :param revprops: Properties for new revision
219
233
        :param local: Perform a local only commit.
 
234
        :param reporter: the reporter to use or None for the default
 
235
        :param verbose: if True and the reporter is not None, report everything
 
236
        :param recursive: If set to 'down', commit in any subtrees that have
 
237
            pending changes of any sort during this commit.
 
238
        :param exclude: None or a list of relative paths to exclude from the
 
239
            commit. Pending changes to excluded files will be ignored by the
 
240
            commit. 
220
241
        """
221
242
        mutter('preparing to commit')
222
243
 
223
 
        if deprecated_passed(branch):
224
 
            warn("Commit.commit (branch, ...): The branch parameter is "
225
 
                 "deprecated as of bzr 0.8. Please use working_tree= instead.",
226
 
                 DeprecationWarning, stacklevel=2)
227
 
            self.branch = branch
228
 
            self.work_tree = self.branch.bzrdir.open_workingtree()
229
 
        elif working_tree is None:
230
 
            raise BzrError("One of branch and working_tree must be passed into commit().")
 
244
        if working_tree is None:
 
245
            raise BzrError("working_tree must be passed into commit().")
231
246
        else:
232
247
            self.work_tree = working_tree
233
248
            self.branch = self.work_tree.branch
234
 
        if message is None:
235
 
            raise BzrError("The message keyword parameter is required for commit().")
 
249
            if getattr(self.work_tree, 'requires_rich_root', lambda: False)():
 
250
                if not self.branch.repository.supports_rich_root():
 
251
                    raise errors.RootNotRich()
 
252
        if message_callback is None:
 
253
            if message is not None:
 
254
                if isinstance(message, str):
 
255
                    message = message.decode(get_user_encoding())
 
256
                message_callback = lambda x: message
 
257
            else:
 
258
                raise BzrError("The message or message_callback keyword"
 
259
                               " parameter is required for commit().")
236
260
 
237
261
        self.bound_branch = None
 
262
        self.any_entries_changed = False
 
263
        self.any_entries_deleted = False
 
264
        if exclude is not None:
 
265
            self.exclude = sorted(
 
266
                minimum_path_selection(exclude))
 
267
        else:
 
268
            self.exclude = []
238
269
        self.local = local
239
270
        self.master_branch = None
240
271
        self.master_locked = False
 
272
        self.recursive = recursive
241
273
        self.rev_id = None
242
 
        self.specific_files = specific_files
 
274
        if specific_files is not None:
 
275
            self.specific_files = sorted(
 
276
                minimum_path_selection(specific_files))
 
277
        else:
 
278
            self.specific_files = None
 
279
        self.specific_file_ids = None
243
280
        self.allow_pointless = allow_pointless
244
 
 
245
 
        if reporter is None and self.reporter is None:
246
 
            self.reporter = NullCommitReporter()
247
 
        elif reporter is not None:
248
 
            self.reporter = reporter
 
281
        self.revprops = revprops
 
282
        self.message_callback = message_callback
 
283
        self.timestamp = timestamp
 
284
        self.timezone = timezone
 
285
        self.committer = committer
 
286
        self.strict = strict
 
287
        self.verbose = verbose
249
288
 
250
289
        self.work_tree.lock_write()
251
290
        self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
291
        self.basis_revid = self.work_tree.last_revision()
 
292
        self.basis_tree = self.work_tree.basis_tree()
 
293
        self.basis_tree.lock_read()
252
294
        try:
253
295
            # Cannot commit with conflicts present.
254
 
            if len(self.work_tree.conflicts())>0:
 
296
            if len(self.work_tree.conflicts()) > 0:
255
297
                raise ConflictsInTree
256
298
 
257
 
            # setup the bound branch variables as needed.
258
 
            self._check_bound_branch()
259
 
 
260
 
            # check for out of date working trees
261
 
            # if we are bound, then self.branch is the master branch and this
262
 
            # test is thus all we need.
263
 
            if self.work_tree.last_revision() != self.master_branch.last_revision():
264
 
                raise errors.OutOfDateTree(self.work_tree)
265
 
    
266
 
            if strict:
267
 
                # raise an exception as soon as we find a single unknown.
268
 
                for unknown in self.work_tree.unknowns():
269
 
                    raise StrictCommitFailed()
270
 
                   
 
299
            # Setup the bound branch variables as needed.
 
300
            self._check_bound_branch(possible_master_transports)
 
301
 
 
302
            # Check that the working tree is up to date
 
303
            old_revno, new_revno = self._check_out_of_date_tree()
 
304
 
 
305
            # Complete configuration setup
 
306
            if reporter is not None:
 
307
                self.reporter = reporter
 
308
            elif self.reporter is None:
 
309
                self.reporter = self._select_reporter()
271
310
            if self.config is None:
272
 
                self.config = bzrlib.config.BranchConfig(self.branch)
273
 
      
274
 
            if isinstance(message, str):
275
 
                message = message.decode(bzrlib.user_encoding)
276
 
            assert isinstance(message, unicode), type(message)
277
 
            self.message = message
278
 
            self._escape_commit_message()
279
 
 
280
 
            self.work_inv = self.work_tree.inventory
281
 
            self.basis_tree = self.work_tree.basis_tree()
 
311
                self.config = self.branch.get_config()
 
312
 
 
313
            # If provided, ensure the specified files are versioned
 
314
            if self.specific_files is not None:
 
315
                # Note: This routine is being called because it raises
 
316
                # PathNotVersionedError as a side effect of finding the IDs. We
 
317
                # later use the ids we found as input to the working tree
 
318
                # inventory iterator, so we only consider those ids rather than
 
319
                # examining the whole tree again.
 
320
                # XXX: Dont we have filter_unversioned to do this more
 
321
                # cheaply?
 
322
                self.specific_file_ids = tree.find_ids_across_trees(
 
323
                    specific_files, [self.basis_tree, self.work_tree])
 
324
 
 
325
            # Setup the progress bar. As the number of files that need to be
 
326
            # committed in unknown, progress is reported as stages.
 
327
            # We keep track of entries separately though and include that
 
328
            # information in the progress bar during the relevant stages.
 
329
            self.pb_stage_name = ""
 
330
            self.pb_stage_count = 0
 
331
            self.pb_stage_total = 5
 
332
            if self.bound_branch:
 
333
                self.pb_stage_total += 1
 
334
            self.pb.show_pct = False
 
335
            self.pb.show_spinner = False
 
336
            self.pb.show_eta = False
 
337
            self.pb.show_count = True
 
338
            self.pb.show_bar = True
 
339
 
282
340
            self.basis_inv = self.basis_tree.inventory
283
 
            # one to finish, one for rev and inventory, and one for each
284
 
            # inventory entry, and the same for the new inventory.
285
 
            # note that this estimate is too long when we do a partial tree
286
 
            # commit which excludes some new files from being considered.
287
 
            # The estimate is corrected when we populate the new inv.
288
 
            self.pb_total = len(self.work_inv) + 5
289
 
            self.pb_count = 0
290
 
 
291
341
            self._gather_parents()
 
342
            # After a merge, a selected file commit is not supported.
 
343
            # See 'bzr help merge' for an explanation as to why.
292
344
            if len(self.parents) > 1 and self.specific_files:
293
 
                raise NotImplementedError('selected-file commit of merges is not supported yet: files %r',
294
 
                        self.specific_files)
295
 
            self._check_parents_present()
296
 
            self.builder = self.branch.get_commit_builder(self.parents, 
 
345
                raise errors.CannotCommitSelectedFileMerge(self.specific_files)
 
346
            # Excludes are a form of selected file commit.
 
347
            if len(self.parents) > 1 and self.exclude:
 
348
                raise errors.CannotCommitSelectedFileMerge(self.exclude)
 
349
 
 
350
            # Collect the changes
 
351
            self._set_progress_stage("Collecting changes",
 
352
                    entries_title="Directory")
 
353
            self.builder = self.branch.get_commit_builder(self.parents,
297
354
                self.config, timestamp, timezone, committer, revprops, rev_id)
298
 
            
299
 
            self._remove_deleted()
300
 
            self._populate_new_inv()
301
 
            self._report_deletes()
302
 
 
303
 
            if not (self.allow_pointless
304
 
                    or len(self.parents) > 1
305
 
                    or self.builder.new_inventory != self.basis_inv):
306
 
                raise PointlessCommit()
307
 
 
308
 
            self._emit_progress_update()
309
 
            # TODO: Now the new inventory is known, check for conflicts and prompt the 
310
 
            # user for a commit message.
311
 
            self.builder.finish_inventory()
312
 
            self._emit_progress_update()
313
 
            self.rev_id = self.builder.commit(self.message)
314
 
            self._emit_progress_update()
315
 
            # revision data is in the local branch now.
316
 
            
317
 
            # upload revision data to the master.
 
355
 
 
356
            try:
 
357
                self.builder.will_record_deletes()
 
358
                # find the location being committed to
 
359
                if self.bound_branch:
 
360
                    master_location = self.master_branch.base
 
361
                else:
 
362
                    master_location = self.branch.base
 
363
 
 
364
                # report the start of the commit
 
365
                self.reporter.started(new_revno, self.rev_id, master_location)
 
366
 
 
367
                self._update_builder_with_changes()
 
368
                self._report_and_accumulate_deletes()
 
369
                self._check_pointless()
 
370
 
 
371
                # TODO: Now the new inventory is known, check for conflicts.
 
372
                # ADHB 2006-08-08: If this is done, populate_new_inv should not add
 
373
                # weave lines, because nothing should be recorded until it is known
 
374
                # that commit will succeed.
 
375
                self._set_progress_stage("Saving data locally")
 
376
                self.builder.finish_inventory()
 
377
 
 
378
                # Prompt the user for a commit message if none provided
 
379
                message = message_callback(self)
 
380
                self.message = message
 
381
                self._escape_commit_message()
 
382
 
 
383
                # Add revision data to the local branch
 
384
                self.rev_id = self.builder.commit(self.message)
 
385
 
 
386
            except Exception, e:
 
387
                mutter("aborting commit write group because of exception:")
 
388
                trace.log_exception_quietly()
 
389
                note("aborting commit write group: %r" % (e,))
 
390
                self.builder.abort()
 
391
                raise
 
392
 
 
393
            self._process_pre_hooks(old_revno, new_revno)
 
394
 
 
395
            # Upload revision data to the master.
318
396
            # this will propagate merged revisions too if needed.
319
397
            if self.bound_branch:
320
 
                self.master_branch.repository.fetch(self.branch.repository,
321
 
                                                    revision_id=self.rev_id)
 
398
                if not self.master_branch.repository.has_same_location(
 
399
                        self.branch.repository):
 
400
                    self._set_progress_stage("Uploading data to master branch")
 
401
                    self.master_branch.repository.fetch(self.branch.repository,
 
402
                        revision_id=self.rev_id)
322
403
                # now the master has the revision data
323
 
                # 'commit' to the master first so a timeout here causes the local
324
 
                # branch to be out of date
325
 
                self.master_branch.append_revision(self.rev_id)
 
404
                # 'commit' to the master first so a timeout here causes the
 
405
                # local branch to be out of date
 
406
                self.master_branch.set_last_revision_info(new_revno,
 
407
                                                          self.rev_id)
326
408
 
327
409
            # and now do the commit locally.
328
 
            self.branch.append_revision(self.rev_id)
 
410
            self.branch.set_last_revision_info(new_revno, self.rev_id)
329
411
 
330
 
            self.work_tree.set_pending_merges([])
331
 
            self.work_tree.set_last_revision(self.rev_id)
332
 
            # now the work tree is up to date with the branch
333
 
            
334
 
            self.reporter.completed(self.branch.revno(), self.rev_id)
335
 
            if self.config.post_commit() is not None:
336
 
                hooks = self.config.post_commit().split(' ')
337
 
                # this would be nicer with twisted.python.reflect.namedAny
338
 
                for hook in hooks:
339
 
                    result = eval(hook + '(branch, rev_id)',
340
 
                                  {'branch':self.branch,
341
 
                                   'bzrlib':bzrlib,
342
 
                                   'rev_id':self.rev_id})
343
 
            self._emit_progress_update()
 
412
            # Make the working tree up to date with the branch
 
413
            self._set_progress_stage("Updating the working tree")
 
414
            self.work_tree.update_basis_by_delta(self.rev_id,
 
415
                 self.builder.get_basis_delta())
 
416
            self.reporter.completed(new_revno, self.rev_id)
 
417
            self._process_post_hooks(old_revno, new_revno)
344
418
        finally:
345
419
            self._cleanup()
346
 
 
347
 
    def _check_bound_branch(self):
 
420
        return self.rev_id
 
421
 
 
422
    def _select_reporter(self):
 
423
        """Select the CommitReporter to use."""
 
424
        if is_quiet():
 
425
            return NullCommitReporter()
 
426
        return ReportCommitToLog()
 
427
 
 
428
    def _check_pointless(self):
 
429
        if self.allow_pointless:
 
430
            return
 
431
        # A merge with no effect on files
 
432
        if len(self.parents) > 1:
 
433
            return
 
434
        # TODO: we could simplify this by using self.builder.basis_delta.
 
435
 
 
436
        # The initial commit adds a root directory, but this in itself is not
 
437
        # a worthwhile commit.
 
438
        if (self.basis_revid == revision.NULL_REVISION and
 
439
            len(self.builder.new_inventory) == 1):
 
440
            raise PointlessCommit()
 
441
        # If length == 1, then we only have the root entry. Which means
 
442
        # that there is no real difference (only the root could be different)
 
443
        # unless deletes occured, in which case the length is irrelevant.
 
444
        if (self.any_entries_deleted or 
 
445
            (len(self.builder.new_inventory) != 1 and
 
446
             self.any_entries_changed)):
 
447
            return
 
448
        raise PointlessCommit()
 
449
 
 
450
    def _check_bound_branch(self, possible_master_transports=None):
348
451
        """Check to see if the local branch is bound.
349
452
 
350
453
        If it is bound, then most of the commit will actually be
355
458
            raise errors.LocalRequiresBoundBranch()
356
459
 
357
460
        if not self.local:
358
 
            self.master_branch = self.branch.get_master_branch()
 
461
            self.master_branch = self.branch.get_master_branch(
 
462
                possible_master_transports)
359
463
 
360
464
        if not self.master_branch:
361
465
            # make this branch the reference branch for out of date checks.
374
478
        #       to local.
375
479
        
376
480
        # Make sure the local branch is identical to the master
377
 
        master_rh = self.master_branch.revision_history()
378
 
        local_rh = self.branch.revision_history()
379
 
        if local_rh != master_rh:
 
481
        master_info = self.master_branch.last_revision_info()
 
482
        local_info = self.branch.last_revision_info()
 
483
        if local_info != master_info:
380
484
            raise errors.BoundBranchOutOfDate(self.branch,
381
485
                    self.master_branch)
382
486
 
385
489
        self.bound_branch = self.branch
386
490
        self.master_branch.lock_write()
387
491
        self.master_locked = True
388
 
####        
389
 
####        # Check to see if we have any pending merges. If we do
390
 
####        # those need to be pushed into the master branch
391
 
####        pending_merges = self.work_tree.pending_merges()
392
 
####        if pending_merges:
393
 
####            for revision_id in pending_merges:
394
 
####                self.master_branch.repository.fetch(self.bound_branch.repository,
395
 
####                                                    revision_id=revision_id)
 
492
 
 
493
    def _check_out_of_date_tree(self):
 
494
        """Check that the working tree is up to date.
 
495
 
 
496
        :return: old_revision_number,new_revision_number tuple
 
497
        """
 
498
        try:
 
499
            first_tree_parent = self.work_tree.get_parent_ids()[0]
 
500
        except IndexError:
 
501
            # if there are no parents, treat our parent as 'None'
 
502
            # this is so that we still consider the master branch
 
503
            # - in a checkout scenario the tree may have no
 
504
            # parents but the branch may do.
 
505
            first_tree_parent = bzrlib.revision.NULL_REVISION
 
506
        old_revno, master_last = self.master_branch.last_revision_info()
 
507
        if master_last != first_tree_parent:
 
508
            if master_last != bzrlib.revision.NULL_REVISION:
 
509
                raise errors.OutOfDateTree(self.work_tree)
 
510
        if self.branch.repository.has_revision(first_tree_parent):
 
511
            new_revno = old_revno + 1
 
512
        else:
 
513
            # ghost parents never appear in revision history.
 
514
            new_revno = 1
 
515
        return old_revno,new_revno
 
516
 
 
517
    def _process_pre_hooks(self, old_revno, new_revno):
 
518
        """Process any registered pre commit hooks."""
 
519
        self._set_progress_stage("Running pre_commit hooks")
 
520
        self._process_hooks("pre_commit", old_revno, new_revno)
 
521
 
 
522
    def _process_post_hooks(self, old_revno, new_revno):
 
523
        """Process any registered post commit hooks."""
 
524
        # Process the post commit hooks, if any
 
525
        self._set_progress_stage("Running post_commit hooks")
 
526
        # old style commit hooks - should be deprecated ? (obsoleted in
 
527
        # 0.15)
 
528
        if self.config.post_commit() is not None:
 
529
            hooks = self.config.post_commit().split(' ')
 
530
            # this would be nicer with twisted.python.reflect.namedAny
 
531
            for hook in hooks:
 
532
                result = eval(hook + '(branch, rev_id)',
 
533
                              {'branch':self.branch,
 
534
                               'bzrlib':bzrlib,
 
535
                               'rev_id':self.rev_id})
 
536
        # process new style post commit hooks
 
537
        self._process_hooks("post_commit", old_revno, new_revno)
 
538
 
 
539
    def _process_hooks(self, hook_name, old_revno, new_revno):
 
540
        if not Branch.hooks[hook_name]:
 
541
            return
 
542
        
 
543
        # new style commit hooks:
 
544
        if not self.bound_branch:
 
545
            hook_master = self.branch
 
546
            hook_local = None
 
547
        else:
 
548
            hook_master = self.master_branch
 
549
            hook_local = self.branch
 
550
        # With bound branches, when the master is behind the local branch,
 
551
        # the 'old_revno' and old_revid values here are incorrect.
 
552
        # XXX: FIXME ^. RBC 20060206
 
553
        if self.parents:
 
554
            old_revid = self.parents[0]
 
555
        else:
 
556
            old_revid = bzrlib.revision.NULL_REVISION
 
557
        
 
558
        if hook_name == "pre_commit":
 
559
            future_tree = self.builder.revision_tree()
 
560
            tree_delta = future_tree.changes_from(self.basis_tree,
 
561
                                             include_root=True)
 
562
        
 
563
        for hook in Branch.hooks[hook_name]:
 
564
            # show the running hook in the progress bar. As hooks may
 
565
            # end up doing nothing (e.g. because they are not configured by
 
566
            # the user) this is still showing progress, not showing overall
 
567
            # actions - its up to each plugin to show a UI if it want's to
 
568
            # (such as 'Emailing diff to foo@example.com').
 
569
            self.pb_stage_name = "Running %s hooks [%s]" % \
 
570
                (hook_name, Branch.hooks.get_hook_name(hook))
 
571
            self._emit_progress()
 
572
            if 'hooks' in debug.debug_flags:
 
573
                mutter("Invoking commit hook: %r", hook)
 
574
            if hook_name == "post_commit":
 
575
                hook(hook_local, hook_master, old_revno, old_revid, new_revno,
 
576
                     self.rev_id)
 
577
            elif hook_name == "pre_commit":
 
578
                hook(hook_local, hook_master,
 
579
                     old_revno, old_revid, new_revno, self.rev_id,
 
580
                     tree_delta, future_tree)
396
581
 
397
582
    def _cleanup(self):
398
583
        """Cleanup any open locks, progress bars etc."""
399
584
        cleanups = [self._cleanup_bound_branch,
 
585
                    self.basis_tree.unlock,
400
586
                    self.work_tree.unlock,
401
587
                    self.pb.finished]
402
588
        found_exception = None
451
637
        """Record the parents of a merge for merge detection."""
452
638
        # TODO: Make sure that this list doesn't contain duplicate 
453
639
        # entries and the order is preserved when doing this.
454
 
        pending_merges = self.work_tree.pending_merges()
455
 
        self.parents = []
456
 
        self.parent_invs = []
457
 
        precursor_id = self.branch.last_revision()
458
 
        if precursor_id:
459
 
            self.parents.append(precursor_id)
460
 
        self.parents += pending_merges
461
 
        for revision in self.parents:
 
640
        self.parents = self.work_tree.get_parent_ids()
 
641
        self.parent_invs = [self.basis_inv]
 
642
        for revision in self.parents[1:]:
462
643
            if self.branch.repository.has_revision(revision):
 
644
                mutter('commit parent revision {%s}', revision)
463
645
                inventory = self.branch.repository.get_inventory(revision)
464
646
                self.parent_invs.append(inventory)
465
 
 
466
 
    def _check_parents_present(self):
467
 
        for parent_id in self.parents:
468
 
            mutter('commit parent revision {%s}', parent_id)
469
 
            if not self.branch.repository.has_revision(parent_id):
470
 
                if parent_id == self.branch.last_revision():
471
 
                    warning("parent is missing %r", parent_id)
472
 
                    raise HistoryMissing(self.branch, 'revision', parent_id)
473
 
                else:
474
 
                    mutter("commit will ghost revision %r", parent_id)
475
 
            
476
 
    def _remove_deleted(self):
477
 
        """Remove deleted files from the working inventories.
478
 
 
479
 
        This is done prior to taking the working inventory as the
480
 
        basis for the new committed inventory.
481
 
 
482
 
        This returns true if any files
483
 
        *that existed in the basis inventory* were deleted.
484
 
        Files that were added and deleted
485
 
        in the working copy don't matter.
 
647
            else:
 
648
                mutter('commit parent ghost revision {%s}', revision)
 
649
 
 
650
    def _update_builder_with_changes(self):
 
651
        """Update the commit builder with the data about what has changed.
486
652
        """
487
 
        specific = self.specific_files
 
653
        # Build the revision inventory.
 
654
        #
 
655
        # This starts by creating a new empty inventory. Depending on
 
656
        # which files are selected for commit, and what is present in the
 
657
        # current tree, the new inventory is populated. inventory entries 
 
658
        # which are candidates for modification have their revision set to
 
659
        # None; inventory entries that are carried over untouched have their
 
660
        # revision set to their prior value.
 
661
        #
 
662
        # ESEPARATIONOFCONCERNS: this function is diffing and using the diff
 
663
        # results to create a new inventory at the same time, which results
 
664
        # in bugs like #46635.  Any reason not to use/enhance Tree.changes_from?
 
665
        # ADHB 11-07-2006
 
666
 
 
667
        exclude = self.exclude
 
668
        specific_files = self.specific_files or []
 
669
        mutter("Selecting files for commit with filter %s", specific_files)
 
670
 
 
671
        # Build the new inventory
 
672
        self._populate_from_inventory()
 
673
 
 
674
        # If specific files are selected, then all un-selected files must be
 
675
        # recorded in their previous state. For more details, see
 
676
        # https://lists.ubuntu.com/archives/bazaar/2007q3/028476.html.
 
677
        if specific_files or exclude:
 
678
            for path, old_ie in self.basis_inv.iter_entries():
 
679
                if old_ie.file_id in self.builder.new_inventory:
 
680
                    # already added - skip.
 
681
                    continue
 
682
                if (is_inside_any(specific_files, path)
 
683
                    and not is_inside_any(exclude, path)):
 
684
                    # was inside the selected path, and not excluded - if not
 
685
                    # present it has been deleted so skip.
 
686
                    continue
 
687
                # From here down it was either not selected, or was excluded:
 
688
                if old_ie.kind == 'directory':
 
689
                    self._next_progress_entry()
 
690
                # We preserve the entry unaltered.
 
691
                ie = old_ie.copy()
 
692
                # Note: specific file commits after a merge are currently
 
693
                # prohibited. This test is for sanity/safety in case it's
 
694
                # required after that changes.
 
695
                if len(self.parents) > 1:
 
696
                    ie.revision = None
 
697
                _, version_recorded, _ = self.builder.record_entry_contents(
 
698
                    ie, self.parent_invs, path, self.basis_tree, None)
 
699
                if version_recorded:
 
700
                    self.any_entries_changed = True
 
701
 
 
702
    def _report_and_accumulate_deletes(self):
 
703
        # XXX: Could the list of deleted paths and ids be instead taken from
 
704
        # _populate_from_inventory?
 
705
        if (isinstance(self.basis_inv, Inventory)
 
706
            and isinstance(self.builder.new_inventory, Inventory)):
 
707
            # the older Inventory classes provide a _byid dict, and building a
 
708
            # set from the keys of this dict is substantially faster than even
 
709
            # getting a set of ids from the inventory
 
710
            #
 
711
            # <lifeless> set(dict) is roughly the same speed as
 
712
            # set(iter(dict)) and both are significantly slower than
 
713
            # set(dict.keys())
 
714
            deleted_ids = set(self.basis_inv._byid.keys()) - \
 
715
               set(self.builder.new_inventory._byid.keys())
 
716
        else:
 
717
            deleted_ids = set(self.basis_inv) - set(self.builder.new_inventory)
 
718
        if deleted_ids:
 
719
            self.any_entries_deleted = True
 
720
            deleted = [(self.basis_tree.id2path(file_id), file_id)
 
721
                for file_id in deleted_ids]
 
722
            deleted.sort()
 
723
            # XXX: this is not quite directory-order sorting
 
724
            for path, file_id in deleted:
 
725
                self.builder.record_delete(path, file_id)
 
726
                self.reporter.deleted(path)
 
727
 
 
728
    def _populate_from_inventory(self):
 
729
        """Populate the CommitBuilder by walking the working tree inventory."""
 
730
        if self.strict:
 
731
            # raise an exception as soon as we find a single unknown.
 
732
            for unknown in self.work_tree.unknowns():
 
733
                raise StrictCommitFailed()
 
734
        
 
735
        specific_files = self.specific_files
 
736
        exclude = self.exclude
 
737
        report_changes = self.reporter.is_verbose()
488
738
        deleted_ids = []
489
 
        for path, ie in self.work_inv.iter_entries():
490
 
            if specific and not is_inside_any(specific, path):
 
739
        # A tree of paths that have been deleted. E.g. if foo/bar has been
 
740
        # deleted, then we have {'foo':{'bar':{}}}
 
741
        deleted_paths = {}
 
742
        # XXX: Note that entries may have the wrong kind because the entry does
 
743
        # not reflect the status on disk.
 
744
        work_inv = self.work_tree.inventory
 
745
        # NB: entries will include entries within the excluded ids/paths
 
746
        # because iter_entries_by_dir has no 'exclude' facility today.
 
747
        entries = work_inv.iter_entries_by_dir(
 
748
            specific_file_ids=self.specific_file_ids, yield_parents=True)
 
749
        for path, existing_ie in entries:
 
750
            file_id = existing_ie.file_id
 
751
            name = existing_ie.name
 
752
            parent_id = existing_ie.parent_id
 
753
            kind = existing_ie.kind
 
754
            if kind == 'directory':
 
755
                self._next_progress_entry()
 
756
            # Skip files that have been deleted from the working tree.
 
757
            # The deleted path ids are also recorded so they can be explicitly
 
758
            # unversioned later.
 
759
            if deleted_paths:
 
760
                path_segments = splitpath(path)
 
761
                deleted_dict = deleted_paths
 
762
                for segment in path_segments:
 
763
                    deleted_dict = deleted_dict.get(segment, None)
 
764
                    if not deleted_dict:
 
765
                        # We either took a path not present in the dict
 
766
                        # (deleted_dict was None), or we've reached an empty
 
767
                        # child dir in the dict, so are now a sub-path.
 
768
                        break
 
769
                else:
 
770
                    deleted_dict = None
 
771
                if deleted_dict is not None:
 
772
                    # the path has a deleted parent, do not add it.
 
773
                    continue
 
774
            if exclude and is_inside_any(exclude, path):
 
775
                # Skip excluded paths. Excluded paths are processed by
 
776
                # _update_builder_with_changes.
491
777
                continue
492
 
            if not self.work_tree.has_filename(path):
493
 
                self.reporter.missing(path)
494
 
                deleted_ids.append((path, ie.file_id))
495
 
        if deleted_ids:
496
 
            deleted_ids.sort(reverse=True)
497
 
            for path, file_id in deleted_ids:
498
 
                del self.work_inv[file_id]
499
 
            self.work_tree._write_inventory(self.work_inv)
500
 
 
501
 
    def _populate_new_inv(self):
502
 
        """Build revision inventory.
503
 
 
504
 
        This creates a new empty inventory. Depending on
505
 
        which files are selected for commit, and what is present in the
506
 
        current tree, the new inventory is populated. inventory entries 
507
 
        which are candidates for modification have their revision set to
508
 
        None; inventory entries that are carried over untouched have their
509
 
        revision set to their prior value.
 
778
            content_summary = self.work_tree.path_content_summary(path)
 
779
            # Note that when a filter of specific files is given, we must only
 
780
            # skip/record deleted files matching that filter.
 
781
            if not specific_files or is_inside_any(specific_files, path):
 
782
                if content_summary[0] == 'missing':
 
783
                    if not deleted_paths:
 
784
                        # path won't have been split yet.
 
785
                        path_segments = splitpath(path)
 
786
                    deleted_dict = deleted_paths
 
787
                    for segment in path_segments:
 
788
                        deleted_dict = deleted_dict.setdefault(segment, {})
 
789
                    self.reporter.missing(path)
 
790
                    deleted_ids.append(file_id)
 
791
                    continue
 
792
            # TODO: have the builder do the nested commit just-in-time IF and
 
793
            # only if needed.
 
794
            if content_summary[0] == 'tree-reference':
 
795
                # enforce repository nested tree policy.
 
796
                if (not self.work_tree.supports_tree_reference() or
 
797
                    # repository does not support it either.
 
798
                    not self.branch.repository._format.supports_tree_reference):
 
799
                    content_summary = ('directory',) + content_summary[1:]
 
800
            kind = content_summary[0]
 
801
            # TODO: specific_files filtering before nested tree processing
 
802
            if kind == 'tree-reference':
 
803
                if self.recursive == 'down':
 
804
                    nested_revision_id = self._commit_nested_tree(
 
805
                        file_id, path)
 
806
                    content_summary = content_summary[:3] + (
 
807
                        nested_revision_id,)
 
808
                else:
 
809
                    content_summary = content_summary[:3] + (
 
810
                        self.work_tree.get_reference_revision(file_id),)
 
811
 
 
812
            # Record an entry for this item
 
813
            # Note: I don't particularly want to have the existing_ie
 
814
            # parameter but the test suite currently (28-Jun-07) breaks
 
815
            # without it thanks to a unicode normalisation issue. :-(
 
816
            definitely_changed = kind != existing_ie.kind
 
817
            self._record_entry(path, file_id, specific_files, kind, name,
 
818
                parent_id, definitely_changed, existing_ie, report_changes,
 
819
                content_summary)
 
820
 
 
821
        # Unversion IDs that were found to be deleted
 
822
        self.work_tree.unversion(deleted_ids)
 
823
 
 
824
    def _commit_nested_tree(self, file_id, path):
 
825
        "Commit a nested tree."
 
826
        sub_tree = self.work_tree.get_nested_tree(file_id, path)
 
827
        # FIXME: be more comprehensive here:
 
828
        # this works when both trees are in --trees repository,
 
829
        # but when both are bound to a different repository,
 
830
        # it fails; a better way of approaching this is to 
 
831
        # finally implement the explicit-caches approach design
 
832
        # a while back - RBC 20070306.
 
833
        if sub_tree.branch.repository.has_same_location(
 
834
            self.work_tree.branch.repository):
 
835
            sub_tree.branch.repository = \
 
836
                self.work_tree.branch.repository
 
837
        try:
 
838
            return sub_tree.commit(message=None, revprops=self.revprops,
 
839
                recursive=self.recursive,
 
840
                message_callback=self.message_callback,
 
841
                timestamp=self.timestamp, timezone=self.timezone,
 
842
                committer=self.committer,
 
843
                allow_pointless=self.allow_pointless,
 
844
                strict=self.strict, verbose=self.verbose,
 
845
                local=self.local, reporter=self.reporter)
 
846
        except errors.PointlessCommit:
 
847
            return self.work_tree.get_reference_revision(file_id)
 
848
 
 
849
    def _record_entry(self, path, file_id, specific_files, kind, name,
 
850
        parent_id, definitely_changed, existing_ie, report_changes,
 
851
        content_summary):
 
852
        "Record the new inventory entry for a path if any."
 
853
        # mutter('check %s {%s}', path, file_id)
 
854
        # mutter('%s selected for commit', path)
 
855
        if definitely_changed or existing_ie is None:
 
856
            ie = make_entry(kind, name, parent_id, file_id)
 
857
        else:
 
858
            ie = existing_ie.copy()
 
859
            ie.revision = None
 
860
        # For carried over entries we don't care about the fs hash - the repo
 
861
        # isn't generating a sha, so we're not saving computation time.
 
862
        _, version_recorded, fs_hash = self.builder.record_entry_contents(
 
863
            ie, self.parent_invs, path, self.work_tree, content_summary)
 
864
        if version_recorded:
 
865
            self.any_entries_changed = True
 
866
        if report_changes:
 
867
            self._report_change(ie, path)
 
868
        if fs_hash:
 
869
            self.work_tree._observed_sha1(ie.file_id, path, fs_hash)
 
870
        return ie
 
871
 
 
872
    def _report_change(self, ie, path):
 
873
        """Report a change to the user.
 
874
 
 
875
        The change that has occurred is described relative to the basis
 
876
        inventory.
510
877
        """
511
 
        mutter("Selecting files for commit with filter %s", self.specific_files)
512
 
        # iter_entries does not visit the ROOT_ID node so we need to call
513
 
        # self._emit_progress_update once by hand.
514
 
        self._emit_progress_update()
515
 
        for path, new_ie in self.work_inv.iter_entries():
516
 
            self._emit_progress_update()
517
 
            file_id = new_ie.file_id
518
 
            mutter('check %s {%s}', path, file_id)
519
 
            if (not self.specific_files or 
520
 
                is_inside_or_parent_of_any(self.specific_files, path)):
521
 
                    mutter('%s selected for commit', path)
522
 
                    ie = new_ie.copy()
523
 
                    ie.revision = None
524
 
            else:
525
 
                mutter('%s not selected for commit', path)
526
 
                if self.basis_inv.has_id(file_id):
527
 
                    ie = self.basis_inv[file_id].copy()
528
 
                else:
529
 
                    # this entry is new and not being committed
530
 
                    continue
531
 
 
532
 
            self.builder.record_entry_contents(ie, self.parent_invs, 
533
 
                path, self.work_tree)
534
 
            # describe the nature of the change that has occurred relative to
535
 
            # the basis inventory.
536
 
            if (self.basis_inv.has_id(ie.file_id)):
537
 
                basis_ie = self.basis_inv[ie.file_id]
538
 
            else:
539
 
                basis_ie = None
540
 
            change = ie.describe_change(basis_ie, ie)
541
 
            if change in (InventoryEntry.RENAMED, 
542
 
                InventoryEntry.MODIFIED_AND_RENAMED):
543
 
                old_path = self.basis_inv.id2path(ie.file_id)
544
 
                self.reporter.renamed(change, old_path, path)
545
 
            else:
546
 
                self.reporter.snapshot_change(change, path)
547
 
 
548
 
    def _emit_progress_update(self):
549
 
        """Emit an update to the progress bar."""
550
 
        self.pb.update("Committing", self.pb_count, self.pb_total)
551
 
        self.pb_count += 1
552
 
 
553
 
    def _report_deletes(self):
554
 
        for path, ie in self.basis_inv.iter_entries():
555
 
            if ie.file_id not in self.builder.new_inventory:
556
 
                self.reporter.deleted(path)
557
 
 
 
878
        if (self.basis_inv.has_id(ie.file_id)):
 
879
            basis_ie = self.basis_inv[ie.file_id]
 
880
        else:
 
881
            basis_ie = None
 
882
        change = ie.describe_change(basis_ie, ie)
 
883
        if change in (InventoryEntry.RENAMED, 
 
884
            InventoryEntry.MODIFIED_AND_RENAMED):
 
885
            old_path = self.basis_inv.id2path(ie.file_id)
 
886
            self.reporter.renamed(change, old_path, path)
 
887
        else:
 
888
            self.reporter.snapshot_change(change, path)
 
889
 
 
890
    def _set_progress_stage(self, name, entries_title=None):
 
891
        """Set the progress stage and emit an update to the progress bar."""
 
892
        self.pb_stage_name = name
 
893
        self.pb_stage_count += 1
 
894
        self.pb_entries_title = entries_title
 
895
        if entries_title is not None:
 
896
            self.pb_entries_count = 0
 
897
            self.pb_entries_total = '?'
 
898
        self._emit_progress()
 
899
 
 
900
    def _next_progress_entry(self):
 
901
        """Emit an update to the progress bar and increment the entry count."""
 
902
        self.pb_entries_count += 1
 
903
        self._emit_progress()
 
904
 
 
905
    def _emit_progress(self):
 
906
        if self.pb_entries_title:
 
907
            if self.pb_entries_total == '?':
 
908
                text = "%s [%s %d] - Stage" % (self.pb_stage_name,
 
909
                    self.pb_entries_title, self.pb_entries_count)
 
910
            else:
 
911
                text = "%s [%s %d/%s] - Stage" % (self.pb_stage_name,
 
912
                    self.pb_entries_title, self.pb_entries_count,
 
913
                    str(self.pb_entries_total))
 
914
        else:
 
915
            text = "%s - Stage" % (self.pb_stage_name)
 
916
        self.pb.update(text, self.pb_stage_count, self.pb_stage_total)
558
917