/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: John Arbash Meinel
  • Date: 2007-04-12 21:33:07 UTC
  • mfrom: (2413.4.1 api-doc-builders)
  • mto: This revision was merged to the branch mainline in revision 2566.
  • Revision ID: john@arbash-meinel.com-20070412213307-kuh07cnzaud12wx1
[merge] api-doc-builder and remove the pydoctor build code for now.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commit.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
from __future__ import absolute_import
18
17
 
19
18
# The newly committed revision is going to have a shape corresponding
20
 
# to that of the working tree.  Files that are not in the
 
19
# to that of the working inventory.  Files that are not in the
21
20
# working tree and that were in the predecessor are reported as
22
21
# removed --- this can include files that were either removed from the
23
22
# inventory or deleted in the working tree.  If they were only
26
25
# We then consider the remaining entries, which will be in the new
27
26
# version.  Directory entries are simply copied across.  File entries
28
27
# must be checked to see if a new version of the file should be
29
 
# recorded.  For each parent revision tree, we check to see what
 
28
# recorded.  For each parent revision inventory, we check to see what
30
29
# version of the file was present.  If the file was present in at
31
30
# least one tree, and if it was the same version in all the trees,
32
31
# then we can just refer to that version.  Otherwise, a new version
50
49
# TODO: Change the parameter 'rev_id' to 'revision_id' to be consistent with
51
50
# the rest of the code; add a deprecation of the old name.
52
51
 
53
 
from . import (
54
 
    debug,
 
52
import os
 
53
import re
 
54
import sys
 
55
import time
 
56
 
 
57
from cStringIO import StringIO
 
58
 
 
59
from bzrlib import (
55
60
    errors,
56
 
    trace,
57
 
    ui,
 
61
    inventory,
 
62
    tree,
58
63
    )
59
 
from .branch import Branch
60
 
from .cleanup import OperationWithCleanups
61
 
import breezy.config
62
 
from .errors import (BzrError,
63
 
                     ConflictsInTree,
64
 
                     StrictCommitFailed
65
 
                     )
66
 
from .osutils import (get_user_encoding,
67
 
                      is_inside_any,
68
 
                      minimum_path_selection,
69
 
                      )
70
 
from .trace import mutter, note, is_quiet
71
 
from .urlutils import unescape_for_display
72
 
from .i18n import gettext
73
 
 
74
 
 
75
 
class PointlessCommit(BzrError):
76
 
 
77
 
    _fmt = "No changes to commit"
78
 
 
79
 
 
80
 
class CannotCommitSelectedFileMerge(BzrError):
81
 
 
82
 
    _fmt = 'Selected-file commit of merges is not supported yet:'\
83
 
        ' files %(files_str)s'
84
 
 
85
 
    def __init__(self, files):
86
 
        files_str = ', '.join(files)
87
 
        BzrError.__init__(self, files=files, files_str=files_str)
88
 
 
89
 
 
90
 
def filter_excluded(iter_changes, exclude):
91
 
    """Filter exclude filenames.
92
 
 
93
 
    :param iter_changes: iter_changes function
94
 
    :param exclude: List of paths to exclude
95
 
    :return: iter_changes function
96
 
    """
97
 
    for change in iter_changes:
98
 
        old_path = change[1][0]
99
 
        new_path = change[1][1]
100
 
 
101
 
        new_excluded = (new_path is not None and
102
 
                        is_inside_any(exclude, new_path))
103
 
 
104
 
        old_excluded = (old_path is not None and
105
 
                        is_inside_any(exclude, old_path))
106
 
 
107
 
        if old_excluded and new_excluded:
108
 
            continue
109
 
 
110
 
        if old_excluded or new_excluded:
111
 
            # TODO(jelmer): Perhaps raise an error here instead?
112
 
            continue
113
 
 
114
 
        yield change
 
64
from bzrlib.branch import Branch
 
65
import bzrlib.config
 
66
from bzrlib.errors import (BzrError, PointlessCommit,
 
67
                           ConflictsInTree,
 
68
                           StrictCommitFailed
 
69
                           )
 
70
from bzrlib.osutils import (kind_marker, isdir,isfile, is_inside_any, 
 
71
                            is_inside_or_parent_of_any,
 
72
                            quotefn, sha_file, split_lines)
 
73
from bzrlib.testament import Testament
 
74
from bzrlib.trace import mutter, note, warning
 
75
from bzrlib.xml5 import serializer_v5
 
76
from bzrlib.inventory import Inventory, InventoryEntry
 
77
from bzrlib import symbol_versioning
 
78
from bzrlib.symbol_versioning import (deprecated_passed,
 
79
        deprecated_function,
 
80
        DEPRECATED_PARAMETER)
 
81
from bzrlib.workingtree import WorkingTree
 
82
import bzrlib.ui
115
83
 
116
84
 
117
85
class NullCommitReporter(object):
118
86
    """I report on progress of a commit."""
119
87
 
120
 
    def started(self, revno, revid, location):
121
 
        pass
122
 
 
123
88
    def snapshot_change(self, change, path):
124
89
        pass
125
90
 
126
91
    def completed(self, revno, rev_id):
127
92
        pass
128
93
 
129
 
    def deleted(self, path):
 
94
    def deleted(self, file_id):
 
95
        pass
 
96
 
 
97
    def escaped(self, escape_count, message):
130
98
        pass
131
99
 
132
100
    def missing(self, path):
135
103
    def renamed(self, change, old_path, new_path):
136
104
        pass
137
105
 
138
 
    def is_verbose(self):
139
 
        return False
140
 
 
141
106
 
142
107
class ReportCommitToLog(NullCommitReporter):
143
108
 
144
 
    def _note(self, format, *args):
145
 
        """Output a message.
146
 
 
147
 
        Subclasses may choose to override this method.
148
 
        """
149
 
        note(format, *args)
 
109
    # this may be more useful if 'note' was replaced by an overridable
 
110
    # method on self, which would allow more trivial subclassing.
 
111
    # alternative, a callable could be passed in, allowing really trivial
 
112
    # reuse for some uis. RBC 20060511
150
113
 
151
114
    def snapshot_change(self, change, path):
152
 
        if path == '' and change in (gettext('added'), gettext('modified')):
153
 
            return
154
 
        self._note("%s %s", change, path)
155
 
 
156
 
    def started(self, revno, rev_id, location):
157
 
        self._note(
158
 
            gettext('Committing to: %s'),
159
 
            unescape_for_display(location, 'utf-8'))
 
115
        if change == 'unchanged':
 
116
            return
 
117
        if change == 'added' and path == '':
 
118
            return
 
119
        note("%s %s", change, path)
160
120
 
161
121
    def completed(self, revno, rev_id):
162
 
        self._note(gettext('Committed revision %d.'), revno)
163
 
        # self._note goes to the console too; so while we want to log the
164
 
        # rev_id, we can't trivially only log it. (See bug 526425). Long
165
 
        # term we should rearrange the reporting structure, but for now
166
 
        # we just mutter seperately. We mutter the revid and revno together
167
 
        # so that concurrent bzr invocations won't lead to confusion.
168
 
        mutter('Committed revid %s as revno %d.', rev_id, revno)
 
122
        note('Committed revision %d.', revno)
 
123
    
 
124
    def deleted(self, file_id):
 
125
        note('deleted %s', file_id)
169
126
 
170
 
    def deleted(self, path):
171
 
        self._note(gettext('deleted %s'), path)
 
127
    def escaped(self, escape_count, message):
 
128
        note("replaced %d control characters in message", escape_count)
172
129
 
173
130
    def missing(self, path):
174
 
        self._note(gettext('missing %s'), path)
 
131
        note('missing %s', path)
175
132
 
176
133
    def renamed(self, change, old_path, new_path):
177
 
        self._note('%s %s => %s', change, old_path, new_path)
178
 
 
179
 
    def is_verbose(self):
180
 
        return True
 
134
        note('%s %s => %s', change, old_path, new_path)
181
135
 
182
136
 
183
137
class Commit(object):
192
146
            the working directory; these should be removed from the
193
147
            working inventory.
194
148
    """
195
 
 
196
149
    def __init__(self,
197
150
                 reporter=None,
198
 
                 config_stack=None):
199
 
        """Create a Commit object.
200
 
 
201
 
        :param reporter: the default reporter to use or None to decide later
202
 
        """
203
 
        self.reporter = reporter
204
 
        self.config_stack = config_stack
205
 
 
206
 
    @staticmethod
207
 
    def update_revprops(revprops, branch, authors=None,
208
 
                        local=False, possible_master_transports=None):
209
 
        if revprops is None:
210
 
            revprops = {}
211
 
        if possible_master_transports is None:
212
 
            possible_master_transports = []
213
 
        if (u'branch-nick' not in revprops and
214
 
                branch.repository._format.supports_storing_branch_nick):
215
 
            revprops[u'branch-nick'] = branch._get_nick(
216
 
                local,
217
 
                possible_master_transports)
218
 
        if authors is not None:
219
 
            if u'author' in revprops or u'authors' in revprops:
220
 
                # XXX: maybe we should just accept one of them?
221
 
                raise AssertionError('author property given twice')
222
 
            if authors:
223
 
                for individual in authors:
224
 
                    if '\n' in individual:
225
 
                        raise AssertionError('\\n is not a valid character '
226
 
                                             'in an author identity')
227
 
                revprops[u'authors'] = '\n'.join(authors)
228
 
        return revprops
229
 
 
 
151
                 config=None):
 
152
        if reporter is not None:
 
153
            self.reporter = reporter
 
154
        else:
 
155
            self.reporter = NullCommitReporter()
 
156
        if config is not None:
 
157
            self.config = config
 
158
        else:
 
159
            self.config = None
 
160
        
230
161
    def commit(self,
231
162
               message=None,
232
163
               timestamp=None,
243
174
               reporter=None,
244
175
               config=None,
245
176
               message_callback=None,
246
 
               recursive='down',
247
 
               exclude=None,
248
 
               possible_master_transports=None,
249
 
               lossy=False):
 
177
               recursive='down'):
250
178
        """Commit working copy as a new revision.
251
179
 
252
 
        :param message: the commit message (it or message_callback is required)
253
 
        :param message_callback: A callback: message =
254
 
            message_callback(cmt_obj)
255
 
 
256
 
        :param timestamp: if not None, seconds-since-epoch for a
257
 
            postdated/predated commit.
258
 
 
259
 
        :param specific_files: If not None, commit only those files. An empty
260
 
            list means 'commit no files'.
261
 
 
262
 
        :param rev_id: If set, use this as the new revision id.
 
180
        message -- the commit message (it or message_callback is required)
 
181
 
 
182
        timestamp -- if not None, seconds-since-epoch for a
 
183
             postdated/predated commit.
 
184
 
 
185
        specific_files -- If true, commit only those files.
 
186
 
 
187
        rev_id -- If set, use this as the new revision id.
263
188
            Useful for test or import commands that need to tightly
264
189
            control what revisions are assigned.  If you duplicate
265
190
            a revision id that exists elsewhere it is your own fault.
266
191
            If null (default), a time/random revision id is generated.
267
192
 
268
 
        :param allow_pointless: If true (default), commit even if nothing
 
193
        allow_pointless -- If true (default), commit even if nothing
269
194
            has changed and no merges are recorded.
270
195
 
271
 
        :param strict: If true, don't allow a commit if the working tree
 
196
        strict -- If true, don't allow a commit if the working tree
272
197
            contains unknown files.
273
198
 
274
 
        :param revprops: Properties for new revision
 
199
        revprops -- Properties for new revision
275
200
        :param local: Perform a local only commit.
276
 
        :param reporter: the reporter to use or None for the default
277
 
        :param verbose: if True and the reporter is not None, report everything
278
201
        :param recursive: If set to 'down', commit in any subtrees that have
279
202
            pending changes of any sort during this commit.
280
 
        :param exclude: None or a list of relative paths to exclude from the
281
 
            commit. Pending changes to excluded files will be ignored by the
282
 
            commit.
283
 
        :param lossy: When committing to a foreign VCS, ignore any
284
 
            data that can not be natively represented.
285
203
        """
286
 
        operation = OperationWithCleanups(self._commit)
287
 
        self.revprops = revprops or {}
288
 
        # XXX: Can be set on __init__ or passed in - this is a bit ugly.
289
 
        self.config_stack = config or self.config_stack
290
 
        return operation.run(
291
 
            message=message,
292
 
            timestamp=timestamp,
293
 
            timezone=timezone,
294
 
            committer=committer,
295
 
            specific_files=specific_files,
296
 
            rev_id=rev_id,
297
 
            allow_pointless=allow_pointless,
298
 
            strict=strict,
299
 
            verbose=verbose,
300
 
            working_tree=working_tree,
301
 
            local=local,
302
 
            reporter=reporter,
303
 
            message_callback=message_callback,
304
 
            recursive=recursive,
305
 
            exclude=exclude,
306
 
            possible_master_transports=possible_master_transports,
307
 
            lossy=lossy)
308
 
 
309
 
    def _commit(self, operation, message, timestamp, timezone, committer,
310
 
                specific_files, rev_id, allow_pointless, strict, verbose,
311
 
                working_tree, local, reporter, message_callback, recursive,
312
 
                exclude, possible_master_transports, lossy):
313
204
        mutter('preparing to commit')
314
205
 
315
206
        if working_tree is None:
322
213
                    raise errors.RootNotRich()
323
214
        if message_callback is None:
324
215
            if message is not None:
325
 
                if isinstance(message, bytes):
326
 
                    message = message.decode(get_user_encoding())
327
 
 
328
 
                def message_callback(x):
329
 
                    return message
 
216
                if isinstance(message, str):
 
217
                    message = message.decode(bzrlib.user_encoding)
 
218
                message_callback = lambda x: message
330
219
            else:
331
220
                raise BzrError("The message or message_callback keyword"
332
221
                               " parameter is required for commit().")
333
222
 
334
223
        self.bound_branch = None
335
 
        self.any_entries_deleted = False
336
 
        if exclude is not None:
337
 
            self.exclude = sorted(
338
 
                minimum_path_selection(exclude))
339
 
        else:
340
 
            self.exclude = []
341
224
        self.local = local
342
225
        self.master_branch = None
343
 
        self.recursive = recursive
 
226
        self.master_locked = False
344
227
        self.rev_id = None
345
 
        # self.specific_files is None to indicate no filter, or any iterable to
346
 
        # indicate a filter - [] means no files at all, as per iter_changes.
347
 
        if specific_files is not None:
348
 
            self.specific_files = sorted(
349
 
                minimum_path_selection(specific_files))
350
 
        else:
351
 
            self.specific_files = None
352
 
 
 
228
        self.specific_files = specific_files
353
229
        self.allow_pointless = allow_pointless
 
230
        self.recursive = recursive
 
231
        self.revprops = revprops
354
232
        self.message_callback = message_callback
355
233
        self.timestamp = timestamp
356
234
        self.timezone = timezone
357
235
        self.committer = committer
 
236
        self.specific_files = specific_files
358
237
        self.strict = strict
359
238
        self.verbose = verbose
 
239
        self.local = local
 
240
 
 
241
        if reporter is None and self.reporter is None:
 
242
            self.reporter = NullCommitReporter()
 
243
        elif reporter is not None:
 
244
            self.reporter = reporter
360
245
 
361
246
        self.work_tree.lock_write()
362
 
        operation.add_cleanup(self.work_tree.unlock)
363
 
        self.parents = self.work_tree.get_parent_ids()
364
 
        self.pb = ui.ui_factory.nested_progress_bar()
365
 
        operation.add_cleanup(self.pb.finished)
366
 
        self.basis_revid = self.work_tree.last_revision()
 
247
        self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
367
248
        self.basis_tree = self.work_tree.basis_tree()
368
249
        self.basis_tree.lock_read()
369
 
        operation.add_cleanup(self.basis_tree.unlock)
370
 
        # Cannot commit with conflicts present.
371
 
        if len(self.work_tree.conflicts()) > 0:
372
 
            raise ConflictsInTree
373
 
 
374
 
        # Setup the bound branch variables as needed.
375
 
        self._check_bound_branch(operation, possible_master_transports)
376
 
 
377
 
        # Check that the working tree is up to date
378
 
        old_revno, old_revid, new_revno = self._check_out_of_date_tree()
379
 
 
380
 
        # Complete configuration setup
381
 
        if reporter is not None:
382
 
            self.reporter = reporter
383
 
        elif self.reporter is None:
384
 
            self.reporter = self._select_reporter()
385
 
        if self.config_stack is None:
386
 
            self.config_stack = self.work_tree.get_config_stack()
387
 
 
388
 
        # Setup the progress bar. As the number of files that need to be
389
 
        # committed in unknown, progress is reported as stages.
390
 
        # We keep track of entries separately though and include that
391
 
        # information in the progress bar during the relevant stages.
392
 
        self.pb_stage_name = ""
393
 
        self.pb_stage_count = 0
394
 
        self.pb_stage_total = 5
395
 
        if self.bound_branch:
396
 
            # 2 extra stages: "Uploading data to master branch" and "Merging
397
 
            # tags to master branch"
398
 
            self.pb_stage_total += 2
399
 
        self.pb.show_pct = False
400
 
        self.pb.show_spinner = False
401
 
        self.pb.show_eta = False
402
 
        self.pb.show_count = True
403
 
        self.pb.show_bar = True
404
 
 
405
 
        # After a merge, a selected file commit is not supported.
406
 
        # See 'bzr help merge' for an explanation as to why.
407
 
        if len(self.parents) > 1 and self.specific_files is not None:
408
 
            raise CannotCommitSelectedFileMerge(self.specific_files)
409
 
        # Excludes are a form of selected file commit.
410
 
        if len(self.parents) > 1 and self.exclude:
411
 
            raise CannotCommitSelectedFileMerge(self.exclude)
412
 
 
413
 
        # Collect the changes
414
 
        self._set_progress_stage("Collecting changes", counter=True)
415
 
        self._lossy = lossy
416
 
        self.builder = self.branch.get_commit_builder(
417
 
            self.parents, self.config_stack, timestamp, timezone, committer,
418
 
            self.revprops, rev_id, lossy=lossy)
419
 
 
420
 
        if self.builder.updates_branch and self.bound_branch:
421
 
            self.builder.abort()
422
 
            raise AssertionError(
423
 
                "bound branches not supported for commit builders "
424
 
                "that update the branch")
425
 
 
426
250
        try:
427
 
            # find the location being committed to
428
 
            if self.bound_branch:
429
 
                master_location = self.master_branch.base
 
251
            # Cannot commit with conflicts present.
 
252
            if len(self.work_tree.conflicts())>0:
 
253
                raise ConflictsInTree
 
254
 
 
255
            # setup the bound branch variables as needed.
 
256
            self._check_bound_branch()
 
257
 
 
258
            # check for out of date working trees
 
259
            try:
 
260
                first_tree_parent = self.work_tree.get_parent_ids()[0]
 
261
            except IndexError:
 
262
                # if there are no parents, treat our parent as 'None'
 
263
                # this is so that we still consier the master branch
 
264
                # - in a checkout scenario the tree may have no
 
265
                # parents but the branch may do.
 
266
                first_tree_parent = bzrlib.revision.NULL_REVISION
 
267
            old_revno, master_last = self.master_branch.last_revision_info()
 
268
            if master_last != first_tree_parent:
 
269
                if master_last != bzrlib.revision.NULL_REVISION:
 
270
                    raise errors.OutOfDateTree(self.work_tree)
 
271
            if self.branch.repository.has_revision(first_tree_parent):
 
272
                new_revno = old_revno + 1
430
273
            else:
431
 
                master_location = self.branch.base
432
 
 
433
 
            # report the start of the commit
434
 
            self.reporter.started(new_revno, self.rev_id, master_location)
435
 
 
436
 
            self._update_builder_with_changes()
 
274
                # ghost parents never appear in revision history.
 
275
                new_revno = 1
 
276
            if strict:
 
277
                # raise an exception as soon as we find a single unknown.
 
278
                for unknown in self.work_tree.unknowns():
 
279
                    raise StrictCommitFailed()
 
280
                   
 
281
            if self.config is None:
 
282
                self.config = self.branch.get_config()
 
283
 
 
284
            self.work_inv = self.work_tree.inventory
 
285
            self.basis_inv = self.basis_tree.inventory
 
286
            if specific_files is not None:
 
287
                # Ensure specified files are versioned
 
288
                # (We don't actually need the ids here)
 
289
                # XXX: Dont we have filter_unversioned to do this more
 
290
                # cheaply?
 
291
                tree.find_ids_across_trees(specific_files,
 
292
                                           [self.basis_tree, self.work_tree])
 
293
            # one to finish, one for rev and inventory, and one for each
 
294
            # inventory entry, and the same for the new inventory.
 
295
            # note that this estimate is too long when we do a partial tree
 
296
            # commit which excludes some new files from being considered.
 
297
            # The estimate is corrected when we populate the new inv.
 
298
            self.pb_total = len(self.work_inv) + 5
 
299
            self.pb_count = 0
 
300
 
 
301
            self._gather_parents()
 
302
            if len(self.parents) > 1 and self.specific_files:
 
303
                raise NotImplementedError('selected-file commit of merges is not supported yet: files %r',
 
304
                        self.specific_files)
 
305
            
 
306
            self.builder = self.branch.get_commit_builder(self.parents,
 
307
                self.config, timestamp, timezone, committer, revprops, rev_id)
 
308
            
 
309
            self._remove_deleted()
 
310
            self._populate_new_inv()
 
311
            self._report_deletes()
 
312
 
437
313
            self._check_pointless()
438
314
 
439
 
            # TODO: Now the new inventory is known, check for conflicts.
 
315
            self._emit_progress_update()
 
316
            # TODO: Now the new inventory is known, check for conflicts and
 
317
            # prompt the user for a commit message.
440
318
            # ADHB 2006-08-08: If this is done, populate_new_inv should not add
441
319
            # weave lines, because nothing should be recorded until it is known
442
320
            # that commit will succeed.
443
 
            self._set_progress_stage("Saving data locally")
444
321
            self.builder.finish_inventory()
445
 
 
446
 
            # Prompt the user for a commit message if none provided
 
322
            self._emit_progress_update()
447
323
            message = message_callback(self)
 
324
            assert isinstance(message, unicode), type(message)
448
325
            self.message = message
 
326
            self._escape_commit_message()
449
327
 
450
 
            # Add revision data to the local branch
451
328
            self.rev_id = self.builder.commit(self.message)
452
 
 
453
 
        except Exception:
454
 
            mutter("aborting commit write group because of exception:")
455
 
            trace.log_exception_quietly()
456
 
            self.builder.abort()
457
 
            raise
458
 
 
459
 
        self._update_branches(old_revno, old_revid, new_revno)
460
 
 
461
 
        # Make the working tree be up to date with the branch. This
462
 
        # includes automatic changes scheduled to be made to the tree, such
463
 
        # as updating its basis and unversioning paths that were missing.
464
 
        self.work_tree.unversion(self.deleted_paths)
465
 
        self._set_progress_stage("Updating the working tree")
466
 
        self.work_tree.update_basis_by_delta(self.rev_id,
467
 
                                             self.builder.get_basis_delta())
468
 
        self.reporter.completed(new_revno, self.rev_id)
469
 
        self._process_post_hooks(old_revno, new_revno)
470
 
        return self.rev_id
471
 
 
472
 
    def _update_branches(self, old_revno, old_revid, new_revno):
473
 
        """Update the master and local branch to the new revision.
474
 
 
475
 
        This will try to make sure that the master branch is updated
476
 
        before the local branch.
477
 
 
478
 
        :param old_revno: Revision number of master branch before the
479
 
            commit
480
 
        :param old_revid: Tip of master branch before the commit
481
 
        :param new_revno: Revision number of the new commit
482
 
        """
483
 
        if not self.builder.updates_branch:
484
 
            self._process_pre_hooks(old_revno, new_revno)
485
 
 
486
 
            # Upload revision data to the master.
 
329
            self._emit_progress_update()
 
330
            # revision data is in the local branch now.
 
331
            
 
332
            # upload revision data to the master.
487
333
            # this will propagate merged revisions too if needed.
488
334
            if self.bound_branch:
489
 
                self._set_progress_stage("Uploading data to master branch")
490
 
                # 'commit' to the master first so a timeout here causes the
491
 
                # local branch to be out of date
492
 
                (new_revno, self.rev_id) = self.master_branch.import_last_revision_info_and_tags(
493
 
                    self.branch, new_revno, self.rev_id, lossy=self._lossy)
494
 
                if self._lossy:
495
 
                    self.branch.fetch(self.master_branch, self.rev_id)
 
335
                self.master_branch.repository.fetch(self.branch.repository,
 
336
                                                    revision_id=self.rev_id)
 
337
                # now the master has the revision data
 
338
                # 'commit' to the master first so a timeout here causes the local
 
339
                # branch to be out of date
 
340
                self.master_branch.set_last_revision_info(new_revno,
 
341
                                                          self.rev_id)
496
342
 
497
343
            # and now do the commit locally.
498
344
            self.branch.set_last_revision_info(new_revno, self.rev_id)
499
 
        else:
500
 
            try:
501
 
                self._process_pre_hooks(old_revno, new_revno)
502
 
            except BaseException:
503
 
                # The commit builder will already have updated the branch,
504
 
                # revert it.
505
 
                self.branch.set_last_revision_info(old_revno, old_revid)
506
 
                raise
507
 
 
508
 
        # Merge local tags to remote
509
 
        if self.bound_branch:
510
 
            self._set_progress_stage("Merging tags to master branch")
511
 
            tag_updates, tag_conflicts = self.branch.tags.merge_to(
512
 
                self.master_branch.tags)
513
 
            if tag_conflicts:
514
 
                warning_lines = ['    ' + name for name, _, _ in tag_conflicts]
515
 
                note(gettext("Conflicting tags in bound branch:\n{0}".format(
516
 
                    "\n".join(warning_lines))))
517
 
 
518
 
    def _select_reporter(self):
519
 
        """Select the CommitReporter to use."""
520
 
        if is_quiet():
521
 
            return NullCommitReporter()
522
 
        return ReportCommitToLog()
 
345
 
 
346
            rev_tree = self.builder.revision_tree()
 
347
            self.work_tree.set_parent_trees([(self.rev_id, rev_tree)])
 
348
            # now the work tree is up to date with the branch
 
349
            
 
350
            self.reporter.completed(new_revno, self.rev_id)
 
351
            # old style commit hooks - should be deprecated ? (obsoleted in
 
352
            # 0.15)
 
353
            if self.config.post_commit() is not None:
 
354
                hooks = self.config.post_commit().split(' ')
 
355
                # this would be nicer with twisted.python.reflect.namedAny
 
356
                for hook in hooks:
 
357
                    result = eval(hook + '(branch, rev_id)',
 
358
                                  {'branch':self.branch,
 
359
                                   'bzrlib':bzrlib,
 
360
                                   'rev_id':self.rev_id})
 
361
            # new style commit hooks:
 
362
            if not self.bound_branch:
 
363
                hook_master = self.branch
 
364
                hook_local = None
 
365
            else:
 
366
                hook_master = self.master_branch
 
367
                hook_local = self.branch
 
368
            # With bound branches, when the master is behind the local branch,
 
369
            # the 'old_revno' and old_revid values here are incorrect.
 
370
            # XXX: FIXME ^. RBC 20060206
 
371
            if self.parents:
 
372
                old_revid = self.parents[0]
 
373
            else:
 
374
                old_revid = bzrlib.revision.NULL_REVISION
 
375
            for hook in Branch.hooks['post_commit']:
 
376
                hook(hook_local, hook_master, old_revno, old_revid, new_revno,
 
377
                    self.rev_id)
 
378
            self._emit_progress_update()
 
379
        finally:
 
380
            self._cleanup()
 
381
        return self.rev_id
 
382
 
 
383
    def _any_real_changes(self):
 
384
        """Are there real changes between new_inventory and basis?
 
385
 
 
386
        For trees without rich roots, inv.root.revision changes every commit.
 
387
        But if that is the only change, we want to treat it as though there
 
388
        are *no* changes.
 
389
        """
 
390
        new_entries = self.builder.new_inventory.iter_entries()
 
391
        basis_entries = self.basis_inv.iter_entries()
 
392
        new_path, new_root_ie = new_entries.next()
 
393
        basis_path, basis_root_ie = basis_entries.next()
 
394
 
 
395
        # This is a copy of InventoryEntry.__eq__ only leaving out .revision
 
396
        def ie_equal_no_revision(this, other):
 
397
            return ((this.file_id == other.file_id)
 
398
                    and (this.name == other.name)
 
399
                    and (this.symlink_target == other.symlink_target)
 
400
                    and (this.text_sha1 == other.text_sha1)
 
401
                    and (this.text_size == other.text_size)
 
402
                    and (this.text_id == other.text_id)
 
403
                    and (this.parent_id == other.parent_id)
 
404
                    and (this.kind == other.kind)
 
405
                    and (this.executable == other.executable)
 
406
                    and (this.reference_revision == other.reference_revision)
 
407
                    )
 
408
        if not ie_equal_no_revision(new_root_ie, basis_root_ie):
 
409
            return True
 
410
 
 
411
        for new_ie, basis_ie in zip(new_entries, basis_entries):
 
412
            if new_ie != basis_ie:
 
413
                return True
 
414
 
 
415
        # No actual changes present
 
416
        return False
523
417
 
524
418
    def _check_pointless(self):
525
419
        if self.allow_pointless:
527
421
        # A merge with no effect on files
528
422
        if len(self.parents) > 1:
529
423
            return
530
 
        if self.builder.any_changes():
 
424
        # work around the fact that a newly-initted tree does differ from its
 
425
        # basis
 
426
        if len(self.basis_inv) == 0 and len(self.builder.new_inventory) == 1:
 
427
            raise PointlessCommit()
 
428
        # Shortcut, if the number of entries changes, then we obviously have
 
429
        # a change
 
430
        if len(self.builder.new_inventory) != len(self.basis_inv):
 
431
            return
 
432
        # If length == 1, then we only have the root entry. Which means
 
433
        # that there is no real difference (only the root could be different)
 
434
        if (len(self.builder.new_inventory) != 1 and self._any_real_changes()):
531
435
            return
532
436
        raise PointlessCommit()
533
437
 
534
 
    def _check_bound_branch(self, operation, possible_master_transports=None):
 
438
    def _check_bound_branch(self):
535
439
        """Check to see if the local branch is bound.
536
440
 
537
441
        If it is bound, then most of the commit will actually be
542
446
            raise errors.LocalRequiresBoundBranch()
543
447
 
544
448
        if not self.local:
545
 
            self.master_branch = self.branch.get_master_branch(
546
 
                possible_master_transports)
 
449
            self.master_branch = self.branch.get_master_branch()
547
450
 
548
451
        if not self.master_branch:
549
452
            # make this branch the reference branch for out of date checks.
553
456
        # If the master branch is bound, we must fail
554
457
        master_bound_location = self.master_branch.get_bound_location()
555
458
        if master_bound_location:
556
 
            raise errors.CommitToDoubleBoundBranch(
557
 
                self.branch, self.master_branch, master_bound_location)
 
459
            raise errors.CommitToDoubleBoundBranch(self.branch,
 
460
                    self.master_branch, master_bound_location)
558
461
 
559
462
        # TODO: jam 20051230 We could automatically push local
560
463
        #       commits to the remote branch if they would fit.
561
464
        #       But for now, just require remote to be identical
562
465
        #       to local.
563
 
 
 
466
        
564
467
        # Make sure the local branch is identical to the master
565
468
        master_info = self.master_branch.last_revision_info()
566
469
        local_info = self.branch.last_revision_info()
567
470
        if local_info != master_info:
568
471
            raise errors.BoundBranchOutOfDate(self.branch,
569
 
                                              self.master_branch)
 
472
                    self.master_branch)
570
473
 
571
474
        # Now things are ready to change the master branch
572
475
        # so grab the lock
573
476
        self.bound_branch = self.branch
574
477
        self.master_branch.lock_write()
575
 
        operation.add_cleanup(self.master_branch.unlock)
576
 
 
577
 
    def _check_out_of_date_tree(self):
578
 
        """Check that the working tree is up to date.
579
 
 
580
 
        :return: old_revision_number, old_revision_id, new_revision_number
581
 
            tuple
 
478
        self.master_locked = True
 
479
 
 
480
    def _cleanup(self):
 
481
        """Cleanup any open locks, progress bars etc."""
 
482
        cleanups = [self._cleanup_bound_branch,
 
483
                    self.basis_tree.unlock,
 
484
                    self.work_tree.unlock,
 
485
                    self.pb.finished]
 
486
        found_exception = None
 
487
        for cleanup in cleanups:
 
488
            try:
 
489
                cleanup()
 
490
            # we want every cleanup to run no matter what.
 
491
            # so we have a catchall here, but we will raise the
 
492
            # last encountered exception up the stack: and
 
493
            # typically this will be useful enough.
 
494
            except Exception, e:
 
495
                found_exception = e
 
496
        if found_exception is not None: 
 
497
            # don't do a plan raise, because the last exception may have been
 
498
            # trashed, e is our sure-to-work exception even though it loses the
 
499
            # full traceback. XXX: RBC 20060421 perhaps we could check the
 
500
            # exc_info and if its the same one do a plain raise otherwise 
 
501
            # 'raise e' as we do now.
 
502
            raise e
 
503
 
 
504
    def _cleanup_bound_branch(self):
 
505
        """Executed at the end of a try/finally to cleanup a bound branch.
 
506
 
 
507
        If the branch wasn't bound, this is a no-op.
 
508
        If it was, it resents self.branch to the local branch, instead
 
509
        of being the master.
582
510
        """
583
 
        try:
584
 
            first_tree_parent = self.work_tree.get_parent_ids()[0]
585
 
        except IndexError:
586
 
            # if there are no parents, treat our parent as 'None'
587
 
            # this is so that we still consider the master branch
588
 
            # - in a checkout scenario the tree may have no
589
 
            # parents but the branch may do.
590
 
            first_tree_parent = breezy.revision.NULL_REVISION
591
 
        old_revno, master_last = self.master_branch.last_revision_info()
592
 
        if master_last != first_tree_parent:
593
 
            if master_last != breezy.revision.NULL_REVISION:
594
 
                raise errors.OutOfDateTree(self.work_tree)
595
 
        if self.branch.repository.has_revision(first_tree_parent):
596
 
            new_revno = old_revno + 1
597
 
        else:
598
 
            # ghost parents never appear in revision history.
599
 
            new_revno = 1
600
 
        return old_revno, master_last, new_revno
601
 
 
602
 
    def _process_pre_hooks(self, old_revno, new_revno):
603
 
        """Process any registered pre commit hooks."""
604
 
        self._set_progress_stage("Running pre_commit hooks")
605
 
        self._process_hooks("pre_commit", old_revno, new_revno)
606
 
 
607
 
    def _process_post_hooks(self, old_revno, new_revno):
608
 
        """Process any registered post commit hooks."""
609
 
        # Process the post commit hooks, if any
610
 
        self._set_progress_stage("Running post_commit hooks")
611
 
        # old style commit hooks - should be deprecated ? (obsoleted in
612
 
        # 0.15^H^H^H^H 2.5.0)
613
 
        post_commit = self.config_stack.get('post_commit')
614
 
        if post_commit is not None:
615
 
            hooks = post_commit.split(' ')
616
 
            # this would be nicer with twisted.python.reflect.namedAny
617
 
            for hook in hooks:
618
 
                result = eval(hook + '(branch, rev_id)',
619
 
                              {'branch': self.branch,
620
 
                               'breezy': breezy,
621
 
                               'rev_id': self.rev_id})
622
 
        # process new style post commit hooks
623
 
        self._process_hooks("post_commit", old_revno, new_revno)
624
 
 
625
 
    def _process_hooks(self, hook_name, old_revno, new_revno):
626
 
        if not Branch.hooks[hook_name]:
627
 
            return
628
 
 
629
 
        # new style commit hooks:
630
511
        if not self.bound_branch:
631
 
            hook_master = self.branch
632
 
            hook_local = None
633
 
        else:
634
 
            hook_master = self.master_branch
635
 
            hook_local = self.branch
636
 
        # With bound branches, when the master is behind the local branch,
637
 
        # the 'old_revno' and old_revid values here are incorrect.
638
 
        # XXX: FIXME ^. RBC 20060206
639
 
        if self.parents:
640
 
            old_revid = self.parents[0]
641
 
        else:
642
 
            old_revid = breezy.revision.NULL_REVISION
643
 
 
644
 
        if hook_name == "pre_commit":
645
 
            future_tree = self.builder.revision_tree()
646
 
            tree_delta = future_tree.changes_from(self.basis_tree,
647
 
                                                  include_root=True)
648
 
 
649
 
        for hook in Branch.hooks[hook_name]:
650
 
            # show the running hook in the progress bar. As hooks may
651
 
            # end up doing nothing (e.g. because they are not configured by
652
 
            # the user) this is still showing progress, not showing overall
653
 
            # actions - its up to each plugin to show a UI if it want's to
654
 
            # (such as 'Emailing diff to foo@example.com').
655
 
            self.pb_stage_name = "Running %s hooks [%s]" % \
656
 
                (hook_name, Branch.hooks.get_hook_name(hook))
657
 
            self._emit_progress()
658
 
            if 'hooks' in debug.debug_flags:
659
 
                mutter("Invoking commit hook: %r", hook)
660
 
            if hook_name == "post_commit":
661
 
                hook(hook_local, hook_master, old_revno, old_revid, new_revno,
662
 
                     self.rev_id)
663
 
            elif hook_name == "pre_commit":
664
 
                hook(hook_local, hook_master,
665
 
                     old_revno, old_revid, new_revno, self.rev_id,
666
 
                     tree_delta, future_tree)
667
 
 
668
 
    def _update_builder_with_changes(self):
669
 
        """Update the commit builder with the data about what has changed.
670
 
        """
671
 
        specific_files = self.specific_files
672
 
        mutter("Selecting files for commit with filter %r", specific_files)
673
 
 
674
 
        self._check_strict()
675
 
        iter_changes = self.work_tree.iter_changes(
676
 
            self.basis_tree, specific_files=specific_files)
677
 
        if self.exclude:
678
 
            iter_changes = filter_excluded(iter_changes, self.exclude)
679
 
        iter_changes = self._filter_iter_changes(iter_changes)
680
 
        for file_id, path, fs_hash in self.builder.record_iter_changes(
681
 
                self.work_tree, self.basis_revid, iter_changes):
682
 
            self.work_tree._observed_sha1(path, fs_hash)
683
 
 
684
 
    def _filter_iter_changes(self, iter_changes):
685
 
        """Process iter_changes.
686
 
 
687
 
        This method reports on the changes in iter_changes to the user, and
688
 
        converts 'missing' entries in the iter_changes iterator to 'deleted'
689
 
        entries. 'missing' entries have their
690
 
 
691
 
        :param iter_changes: An iter_changes to process.
692
 
        :return: A generator of changes.
693
 
        """
694
 
        reporter = self.reporter
695
 
        report_changes = reporter.is_verbose()
696
 
        deleted_paths = []
697
 
        for change in iter_changes:
698
 
            if report_changes:
699
 
                old_path = change[1][0]
700
 
                new_path = change[1][1]
701
 
                versioned = change[3][1]
702
 
            kind = change[6][1]
703
 
            versioned = change[3][1]
704
 
            if kind is None and versioned:
705
 
                # 'missing' path
706
 
                if report_changes:
707
 
                    reporter.missing(new_path)
708
 
                deleted_paths.append(change[1][1])
709
 
                # Reset the new path (None) and new versioned flag (False)
710
 
                change = (change[0], (change[1][0], None), change[2],
711
 
                          (change[3][0], False)) + change[4:]
712
 
                new_path = change[1][1]
713
 
                versioned = False
714
 
            elif kind == 'tree-reference':
715
 
                if self.recursive == 'down':
716
 
                    self._commit_nested_tree(change[1][1])
717
 
            if change[3][0] or change[3][1]:
718
 
                yield change
719
 
                if report_changes:
720
 
                    if new_path is None:
721
 
                        reporter.deleted(old_path)
722
 
                    elif old_path is None:
723
 
                        reporter.snapshot_change(gettext('added'), new_path)
724
 
                    elif old_path != new_path:
725
 
                        reporter.renamed(gettext('renamed'),
726
 
                                         old_path, new_path)
727
 
                    else:
728
 
                        if (new_path
729
 
                                or self.work_tree.branch.repository._format.rich_root_data):
730
 
                            # Don't report on changes to '' in non rich root
731
 
                            # repositories.
732
 
                            reporter.snapshot_change(
733
 
                                gettext('modified'), new_path)
734
 
            self._next_progress_entry()
735
 
        # Unversion files that were found to be deleted
736
 
        self.deleted_paths = deleted_paths
737
 
 
738
 
    def _check_strict(self):
739
 
        # XXX: when we use iter_changes this would likely be faster if
740
 
        # iter_changes would check for us (even in the presence of
741
 
        # selected_files).
742
 
        if self.strict:
743
 
            # raise an exception as soon as we find a single unknown.
744
 
            for unknown in self.work_tree.unknowns():
745
 
                raise StrictCommitFailed()
746
 
 
747
 
    def _commit_nested_tree(self, path):
748
 
        "Commit a nested tree."
749
 
        sub_tree = self.work_tree.get_nested_tree(path)
750
 
        # FIXME: be more comprehensive here:
751
 
        # this works when both trees are in --trees repository,
752
 
        # but when both are bound to a different repository,
753
 
        # it fails; a better way of approaching this is to
754
 
        # finally implement the explicit-caches approach design
755
 
        # a while back - RBC 20070306.
756
 
        if sub_tree.branch.repository.has_same_location(
757
 
                self.work_tree.branch.repository):
758
 
            sub_tree.branch.repository = \
759
 
                self.work_tree.branch.repository
760
 
        try:
761
 
            return sub_tree.commit(message=None, revprops=self.revprops,
762
 
                                   recursive=self.recursive,
763
 
                                   message_callback=self.message_callback,
764
 
                                   timestamp=self.timestamp,
765
 
                                   timezone=self.timezone,
766
 
                                   committer=self.committer,
767
 
                                   allow_pointless=self.allow_pointless,
768
 
                                   strict=self.strict, verbose=self.verbose,
769
 
                                   local=self.local, reporter=self.reporter)
770
 
        except PointlessCommit:
771
 
            return self.work_tree.get_reference_revision(path)
772
 
 
773
 
    def _set_progress_stage(self, name, counter=False):
774
 
        """Set the progress stage and emit an update to the progress bar."""
775
 
        self.pb_stage_name = name
776
 
        self.pb_stage_count += 1
777
 
        if counter:
778
 
            self.pb_entries_count = 0
779
 
        else:
780
 
            self.pb_entries_count = None
781
 
        self._emit_progress()
782
 
 
783
 
    def _next_progress_entry(self):
784
 
        """Emit an update to the progress bar and increment the entry count."""
785
 
        self.pb_entries_count += 1
786
 
        self._emit_progress()
787
 
 
788
 
    def _emit_progress(self):
789
 
        if self.pb_entries_count is not None:
790
 
            text = gettext("{0} [{1}] - Stage").format(self.pb_stage_name,
791
 
                                                       self.pb_entries_count)
792
 
        else:
793
 
            text = gettext("%s - Stage") % (self.pb_stage_name, )
794
 
        self.pb.update(text, self.pb_stage_count, self.pb_stage_total)
 
512
            return
 
513
        if self.master_locked:
 
514
            self.master_branch.unlock()
 
515
 
 
516
    def _escape_commit_message(self):
 
517
        """Replace xml-incompatible control characters."""
 
518
        # FIXME: RBC 20060419 this should be done by the revision
 
519
        # serialiser not by commit. Then we can also add an unescaper
 
520
        # in the deserializer and start roundtripping revision messages
 
521
        # precisely. See repository_implementations/test_repository.py
 
522
        
 
523
        # Python strings can include characters that can't be
 
524
        # represented in well-formed XML; escape characters that
 
525
        # aren't listed in the XML specification
 
526
        # (http://www.w3.org/TR/REC-xml/#NT-Char).
 
527
        self.message, escape_count = re.subn(
 
528
            u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
 
529
            lambda match: match.group(0).encode('unicode_escape'),
 
530
            self.message)
 
531
        if escape_count:
 
532
            self.reporter.escaped(escape_count, self.message)
 
533
 
 
534
    def _gather_parents(self):
 
535
        """Record the parents of a merge for merge detection."""
 
536
        # TODO: Make sure that this list doesn't contain duplicate 
 
537
        # entries and the order is preserved when doing this.
 
538
        self.parents = self.work_tree.get_parent_ids()
 
539
        self.parent_invs = [self.basis_inv]
 
540
        for revision in self.parents[1:]:
 
541
            if self.branch.repository.has_revision(revision):
 
542
                mutter('commit parent revision {%s}', revision)
 
543
                inventory = self.branch.repository.get_inventory(revision)
 
544
                self.parent_invs.append(inventory)
 
545
            else:
 
546
                mutter('commit parent ghost revision {%s}', revision)
 
547
 
 
548
    def _remove_deleted(self):
 
549
        """Remove deleted files from the working inventories.
 
550
 
 
551
        This is done prior to taking the working inventory as the
 
552
        basis for the new committed inventory.
 
553
 
 
554
        This returns true if any files
 
555
        *that existed in the basis inventory* were deleted.
 
556
        Files that were added and deleted
 
557
        in the working copy don't matter.
 
558
        """
 
559
        specific = self.specific_files
 
560
        deleted_ids = []
 
561
        deleted_paths = set()
 
562
        for path, ie in self.work_inv.iter_entries():
 
563
            if is_inside_any(deleted_paths, path):
 
564
                # The tree will delete the required ids recursively.
 
565
                continue
 
566
            if specific and not is_inside_any(specific, path):
 
567
                continue
 
568
            if not self.work_tree.has_filename(path):
 
569
                deleted_paths.add(path)
 
570
                self.reporter.missing(path)
 
571
                deleted_ids.append(ie.file_id)
 
572
        self.work_tree.unversion(deleted_ids)
 
573
 
 
574
    def _populate_new_inv(self):
 
575
        """Build revision inventory.
 
576
 
 
577
        This creates a new empty inventory. Depending on
 
578
        which files are selected for commit, and what is present in the
 
579
        current tree, the new inventory is populated. inventory entries 
 
580
        which are candidates for modification have their revision set to
 
581
        None; inventory entries that are carried over untouched have their
 
582
        revision set to their prior value.
 
583
        """
 
584
        # ESEPARATIONOFCONCERNS: this function is diffing and using the diff
 
585
        # results to create a new inventory at the same time, which results
 
586
        # in bugs like #46635.  Any reason not to use/enhance Tree.changes_from?
 
587
        # ADHB 11-07-2006
 
588
        mutter("Selecting files for commit with filter %s", self.specific_files)
 
589
        assert self.work_inv.root is not None
 
590
        entries = self.work_inv.iter_entries()
 
591
        if not self.builder.record_root_entry:
 
592
            symbol_versioning.warn('CommitBuilders should support recording'
 
593
                ' the root entry as of bzr 0.10.', DeprecationWarning, 
 
594
                stacklevel=1)
 
595
            self.builder.new_inventory.add(self.basis_inv.root.copy())
 
596
            entries.next()
 
597
            self._emit_progress_update()
 
598
        for path, new_ie in entries:
 
599
            self._emit_progress_update()
 
600
            file_id = new_ie.file_id
 
601
            try:
 
602
                kind = self.work_tree.kind(file_id)
 
603
                if kind == 'tree-reference' and self.recursive == 'down':
 
604
                    # nested tree: commit in it
 
605
                    sub_tree = WorkingTree.open(self.work_tree.abspath(path))
 
606
                    # FIXME: be more comprehensive here:
 
607
                    # this works when both trees are in --trees repository,
 
608
                    # but when both are bound to a different repository,
 
609
                    # it fails; a better way of approaching this is to 
 
610
                    # finally implement the explicit-caches approach design
 
611
                    # a while back - RBC 20070306.
 
612
                    if (sub_tree.branch.repository.bzrdir.root_transport.base
 
613
                        ==
 
614
                        self.work_tree.branch.repository.bzrdir.root_transport.base):
 
615
                        sub_tree.branch.repository = \
 
616
                            self.work_tree.branch.repository
 
617
                    try:
 
618
                        sub_tree.commit(message=None, revprops=self.revprops,
 
619
                            recursive=self.recursive,
 
620
                            message_callback=self.message_callback,
 
621
                            timestamp=self.timestamp, timezone=self.timezone,
 
622
                            committer=self.committer,
 
623
                            allow_pointless=self.allow_pointless,
 
624
                            strict=self.strict, verbose=self.verbose,
 
625
                            local=self.local, reporter=self.reporter)
 
626
                    except errors.PointlessCommit:
 
627
                        pass
 
628
                if kind != new_ie.kind:
 
629
                    new_ie = inventory.make_entry(kind, new_ie.name,
 
630
                                                  new_ie.parent_id, file_id)
 
631
            except errors.NoSuchFile:
 
632
                pass
 
633
            # mutter('check %s {%s}', path, file_id)
 
634
            if (not self.specific_files or 
 
635
                is_inside_or_parent_of_any(self.specific_files, path)):
 
636
                    # mutter('%s selected for commit', path)
 
637
                    ie = new_ie.copy()
 
638
                    ie.revision = None
 
639
            else:
 
640
                # mutter('%s not selected for commit', path)
 
641
                if self.basis_inv.has_id(file_id):
 
642
                    ie = self.basis_inv[file_id].copy()
 
643
                else:
 
644
                    # this entry is new and not being committed
 
645
                    continue
 
646
            self.builder.record_entry_contents(ie, self.parent_invs, 
 
647
                path, self.work_tree)
 
648
            # describe the nature of the change that has occurred relative to
 
649
            # the basis inventory.
 
650
            if (self.basis_inv.has_id(ie.file_id)):
 
651
                basis_ie = self.basis_inv[ie.file_id]
 
652
            else:
 
653
                basis_ie = None
 
654
            change = ie.describe_change(basis_ie, ie)
 
655
            if change in (InventoryEntry.RENAMED, 
 
656
                InventoryEntry.MODIFIED_AND_RENAMED):
 
657
                old_path = self.basis_inv.id2path(ie.file_id)
 
658
                self.reporter.renamed(change, old_path, path)
 
659
            else:
 
660
                self.reporter.snapshot_change(change, path)
 
661
 
 
662
        if not self.specific_files:
 
663
            return
 
664
 
 
665
        # ignore removals that don't match filespec
 
666
        for path, new_ie in self.basis_inv.iter_entries():
 
667
            if new_ie.file_id in self.work_inv:
 
668
                continue
 
669
            if is_inside_any(self.specific_files, path):
 
670
                continue
 
671
            ie = new_ie.copy()
 
672
            ie.revision = None
 
673
            self.builder.record_entry_contents(ie, self.parent_invs, path,
 
674
                                               self.basis_tree)
 
675
 
 
676
    def _emit_progress_update(self):
 
677
        """Emit an update to the progress bar."""
 
678
        self.pb.update("Committing", self.pb_count, self.pb_total)
 
679
        self.pb_count += 1
 
680
 
 
681
    def _report_deletes(self):
 
682
        for path, ie in self.basis_inv.iter_entries():
 
683
            if ie.file_id not in self.builder.new_inventory:
 
684
                self.reporter.deleted(path)
 
685
 
 
686