/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Robert Collins
  • Date: 2008-08-20 02:07:36 UTC
  • mfrom: (3640 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3682.
  • Revision ID: robertc@robertcollins.net-20080820020736-g2xe4921zzxtymle
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

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