/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: v.ladeuil+lp at free
  • Date: 2007-05-20 09:57:58 UTC
  • mto: (2485.8.44 bzr.connection.sharing)
  • mto: This revision was merged to the branch mainline in revision 2646.
  • Revision ID: v.ladeuil+lp@free.fr-20070520095758-6ci8iwmirzd5y6yu
Change the file naming to clearly separate the command behavior
testing.

* bzrlib/tests/__init__.py:
(packages_to_test): Add tests.commands.

* bzrlib/tests/commands/__init__.py: 
New file. Add all command tests to the test suite.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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 ExitStack
61
 
import breezy.config
62
 
from .errors import (BzrError,
63
 
                     ConflictsInTree,
64
 
                     StrictCommitFailed
65
 
                     )
66
 
from .osutils import (get_user_encoding,
67
 
                      has_symlinks,
68
 
                      is_inside_any,
69
 
                      minimum_path_selection,
70
 
                      )
71
 
from .trace import mutter, note, is_quiet
72
 
from .tree import TreeChange
73
 
from .urlutils import unescape_for_display
74
 
from .i18n import gettext
75
 
 
76
 
 
77
 
class PointlessCommit(BzrError):
78
 
 
79
 
    _fmt = "No changes to commit"
80
 
 
81
 
 
82
 
class CannotCommitSelectedFileMerge(BzrError):
83
 
 
84
 
    _fmt = 'Selected-file commit of merges is not supported yet:'\
85
 
        ' files %(files_str)s'
86
 
 
87
 
    def __init__(self, files):
88
 
        files_str = ', '.join(files)
89
 
        BzrError.__init__(self, files=files, files_str=files_str)
90
 
 
91
 
 
92
 
def filter_excluded(iter_changes, exclude):
93
 
    """Filter exclude filenames.
94
 
 
95
 
    :param iter_changes: iter_changes function
96
 
    :param exclude: List of paths to exclude
97
 
    :return: iter_changes function
98
 
    """
99
 
    for change in iter_changes:
100
 
        new_excluded = (change.path[1] is not None and
101
 
                        is_inside_any(exclude, change.path[1]))
102
 
 
103
 
        old_excluded = (change.path[0] is not None and
104
 
                        is_inside_any(exclude, change.path[0]))
105
 
 
106
 
        if old_excluded and new_excluded:
107
 
            continue
108
 
 
109
 
        if old_excluded or new_excluded:
110
 
            # TODO(jelmer): Perhaps raise an error here instead?
111
 
            continue
112
 
 
113
 
        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
114
83
 
115
84
 
116
85
class NullCommitReporter(object):
117
86
    """I report on progress of a commit."""
118
87
 
119
 
    def started(self, revno, revid, location):
120
 
        pass
121
 
 
122
88
    def snapshot_change(self, change, path):
123
89
        pass
124
90
 
125
91
    def completed(self, revno, rev_id):
126
92
        pass
127
93
 
128
 
    def deleted(self, path):
 
94
    def deleted(self, file_id):
 
95
        pass
 
96
 
 
97
    def escaped(self, escape_count, message):
129
98
        pass
130
99
 
131
100
    def missing(self, path):
134
103
    def renamed(self, change, old_path, new_path):
135
104
        pass
136
105
 
137
 
    def is_verbose(self):
138
 
        return False
139
 
 
140
106
 
141
107
class ReportCommitToLog(NullCommitReporter):
142
108
 
143
 
    def _note(self, format, *args):
144
 
        """Output a message.
145
 
 
146
 
        Subclasses may choose to override this method.
147
 
        """
148
 
        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
149
113
 
150
114
    def snapshot_change(self, change, path):
151
 
        if path == '' and change in (gettext('added'), gettext('modified')):
152
 
            return
153
 
        self._note("%s %s", change, path)
154
 
 
155
 
    def started(self, revno, rev_id, location):
156
 
        self._note(
157
 
            gettext('Committing to: %s'),
158
 
            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)
159
120
 
160
121
    def completed(self, revno, rev_id):
161
 
        if revno is not None:
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)
169
 
        else:
170
 
            self._note(gettext('Committed revid %s.'), rev_id)
 
122
        note('Committed revision %d.', revno)
 
123
    
 
124
    def deleted(self, file_id):
 
125
        note('deleted %s', file_id)
171
126
 
172
 
    def deleted(self, path):
173
 
        self._note(gettext('deleted %s'), path)
 
127
    def escaped(self, escape_count, message):
 
128
        note("replaced %d control characters in message", escape_count)
174
129
 
175
130
    def missing(self, path):
176
 
        self._note(gettext('missing %s'), path)
 
131
        note('missing %s', path)
177
132
 
178
133
    def renamed(self, change, old_path, new_path):
179
 
        self._note('%s %s => %s', change, old_path, new_path)
180
 
 
181
 
    def is_verbose(self):
182
 
        return True
 
134
        note('%s %s => %s', change, old_path, new_path)
183
135
 
184
136
 
185
137
class Commit(object):
194
146
            the working directory; these should be removed from the
195
147
            working inventory.
196
148
    """
197
 
 
198
149
    def __init__(self,
199
150
                 reporter=None,
200
 
                 config_stack=None):
201
 
        """Create a Commit object.
202
 
 
203
 
        :param reporter: the default reporter to use or None to decide later
204
 
        """
205
 
        self.reporter = reporter
206
 
        self.config_stack = config_stack
207
 
 
208
 
    @staticmethod
209
 
    def update_revprops(revprops, branch, authors=None,
210
 
                        local=False, possible_master_transports=None):
211
 
        if revprops is None:
212
 
            revprops = {}
213
 
        if possible_master_transports is None:
214
 
            possible_master_transports = []
215
 
        if (u'branch-nick' not in revprops and
216
 
                branch.repository._format.supports_storing_branch_nick):
217
 
            revprops[u'branch-nick'] = branch._get_nick(
218
 
                local,
219
 
                possible_master_transports)
220
 
        if authors is not None:
221
 
            if u'author' in revprops or u'authors' in revprops:
222
 
                # XXX: maybe we should just accept one of them?
223
 
                raise AssertionError('author property given twice')
224
 
            if authors:
225
 
                for individual in authors:
226
 
                    if '\n' in individual:
227
 
                        raise AssertionError('\\n is not a valid character '
228
 
                                             'in an author identity')
229
 
                revprops[u'authors'] = '\n'.join(authors)
230
 
        return revprops
231
 
 
 
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
        
232
161
    def commit(self,
233
162
               message=None,
234
163
               timestamp=None,
245
174
               reporter=None,
246
175
               config=None,
247
176
               message_callback=None,
248
 
               recursive='down',
249
 
               exclude=None,
250
 
               possible_master_transports=None,
251
 
               lossy=False):
 
177
               recursive='down'):
252
178
        """Commit working copy as a new revision.
253
179
 
254
 
        :param message: the commit message (it or message_callback is required)
255
 
        :param message_callback: A callback: message =
256
 
            message_callback(cmt_obj)
257
 
 
258
 
        :param timestamp: if not None, seconds-since-epoch for a
259
 
            postdated/predated commit.
260
 
 
261
 
        :param specific_files: If not None, commit only those files. An empty
262
 
            list means 'commit no files'.
263
 
 
264
 
        :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.
265
188
            Useful for test or import commands that need to tightly
266
189
            control what revisions are assigned.  If you duplicate
267
190
            a revision id that exists elsewhere it is your own fault.
268
191
            If null (default), a time/random revision id is generated.
269
192
 
270
 
        :param allow_pointless: If true (default), commit even if nothing
 
193
        allow_pointless -- If true (default), commit even if nothing
271
194
            has changed and no merges are recorded.
272
195
 
273
 
        :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
274
197
            contains unknown files.
275
198
 
276
 
        :param revprops: Properties for new revision
 
199
        revprops -- Properties for new revision
277
200
        :param local: Perform a local only commit.
278
 
        :param reporter: the reporter to use or None for the default
279
 
        :param verbose: if True and the reporter is not None, report everything
280
201
        :param recursive: If set to 'down', commit in any subtrees that have
281
202
            pending changes of any sort during this commit.
282
 
        :param exclude: None or a list of relative paths to exclude from the
283
 
            commit. Pending changes to excluded files will be ignored by the
284
 
            commit.
285
 
        :param lossy: When committing to a foreign VCS, ignore any
286
 
            data that can not be natively represented.
287
203
        """
288
 
        with ExitStack() as stack:
289
 
            self.revprops = revprops or {}
290
 
            # XXX: Can be set on __init__ or passed in - this is a bit ugly.
291
 
            self.config_stack = config or self.config_stack
292
 
            mutter('preparing to commit')
293
 
 
294
 
            if working_tree is None:
295
 
                raise BzrError("working_tree must be passed into commit().")
296
 
            else:
297
 
                self.work_tree = working_tree
298
 
                self.branch = self.work_tree.branch
299
 
                if getattr(self.work_tree, 'requires_rich_root', lambda: False)():
300
 
                    if not self.branch.repository.supports_rich_root():
301
 
                        raise errors.RootNotRich()
302
 
            if message_callback is None:
303
 
                if message is not None:
304
 
                    if isinstance(message, bytes):
305
 
                        message = message.decode(get_user_encoding())
306
 
 
307
 
                    def message_callback(x):
308
 
                        return message
309
 
                else:
310
 
                    raise BzrError("The message or message_callback keyword"
311
 
                                   " parameter is required for commit().")
312
 
 
313
 
            self.bound_branch = None
314
 
            self.any_entries_deleted = False
315
 
            if exclude is not None:
316
 
                self.exclude = sorted(
317
 
                    minimum_path_selection(exclude))
318
 
            else:
319
 
                self.exclude = []
320
 
            self.local = local
321
 
            self.master_branch = None
322
 
            self.recursive = recursive
323
 
            self.rev_id = None
324
 
            # self.specific_files is None to indicate no filter, or any iterable to
325
 
            # indicate a filter - [] means no files at all, as per iter_changes.
326
 
            if specific_files is not None:
327
 
                self.specific_files = sorted(
328
 
                    minimum_path_selection(specific_files))
329
 
            else:
330
 
                self.specific_files = None
331
 
 
332
 
            self.allow_pointless = allow_pointless
333
 
            self.message_callback = message_callback
334
 
            self.timestamp = timestamp
335
 
            self.timezone = timezone
336
 
            self.committer = committer
337
 
            self.strict = strict
338
 
            self.verbose = verbose
339
 
 
340
 
            stack.enter_context(self.work_tree.lock_write())
341
 
            self.parents = self.work_tree.get_parent_ids()
342
 
            self.pb = ui.ui_factory.nested_progress_bar()
343
 
            stack.callback(self.pb.finished)
344
 
            self.basis_revid = self.work_tree.last_revision()
345
 
            self.basis_tree = self.work_tree.basis_tree()
346
 
            stack.enter_context(self.basis_tree.lock_read())
 
204
        mutter('preparing to commit')
 
205
 
 
206
        if working_tree is None:
 
207
            raise BzrError("working_tree must be passed into commit().")
 
208
        else:
 
209
            self.work_tree = working_tree
 
210
            self.branch = self.work_tree.branch
 
211
            if getattr(self.work_tree, 'requires_rich_root', lambda: False)():
 
212
                if not self.branch.repository.supports_rich_root():
 
213
                    raise errors.RootNotRich()
 
214
        if message_callback is None:
 
215
            if message is not None:
 
216
                if isinstance(message, str):
 
217
                    message = message.decode(bzrlib.user_encoding)
 
218
                message_callback = lambda x: message
 
219
            else:
 
220
                raise BzrError("The message or message_callback keyword"
 
221
                               " parameter is required for commit().")
 
222
 
 
223
        self.bound_branch = None
 
224
        self.local = local
 
225
        self.master_branch = None
 
226
        self.master_locked = False
 
227
        self.rev_id = None
 
228
        self.specific_files = specific_files
 
229
        self.allow_pointless = allow_pointless
 
230
        self.recursive = recursive
 
231
        self.revprops = revprops
 
232
        self.message_callback = message_callback
 
233
        self.timestamp = timestamp
 
234
        self.timezone = timezone
 
235
        self.committer = committer
 
236
        self.specific_files = specific_files
 
237
        self.strict = strict
 
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
 
245
 
 
246
        self.work_tree.lock_write()
 
247
        self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
248
        self.basis_tree = self.work_tree.basis_tree()
 
249
        self.basis_tree.lock_read()
 
250
        try:
347
251
            # Cannot commit with conflicts present.
348
 
            if len(self.work_tree.conflicts()) > 0:
 
252
            if len(self.work_tree.conflicts())>0:
349
253
                raise ConflictsInTree
350
254
 
351
 
            # Setup the bound branch variables as needed.
352
 
            self._check_bound_branch(stack, possible_master_transports)
353
 
            if self.config_stack is None:
354
 
                self.config_stack = self.work_tree.get_config_stack()
355
 
 
356
 
            # Check that the working tree is up to date
357
 
            old_revno, old_revid, new_revno = self._check_out_of_date_tree()
358
 
 
359
 
            # Complete configuration setup
360
 
            if reporter is not None:
361
 
                self.reporter = reporter
362
 
            elif self.reporter is None:
363
 
                self.reporter = self._select_reporter()
364
 
 
365
 
            # Setup the progress bar. As the number of files that need to be
366
 
            # committed in unknown, progress is reported as stages.
367
 
            # We keep track of entries separately though and include that
368
 
            # information in the progress bar during the relevant stages.
369
 
            self.pb_stage_name = ""
370
 
            self.pb_stage_count = 0
371
 
            self.pb_stage_total = 5
372
 
            if self.bound_branch:
373
 
                # 2 extra stages: "Uploading data to master branch" and "Merging
374
 
                # tags to master branch"
375
 
                self.pb_stage_total += 2
376
 
            self.pb.show_pct = False
377
 
            self.pb.show_spinner = False
378
 
            self.pb.show_eta = False
379
 
            self.pb.show_count = True
380
 
            self.pb.show_bar = True
381
 
 
382
 
            # After a merge, a selected file commit is not supported.
383
 
            # See 'bzr help merge' for an explanation as to why.
384
 
            if len(self.parents) > 1 and self.specific_files is not None:
385
 
                raise CannotCommitSelectedFileMerge(self.specific_files)
386
 
            # Excludes are a form of selected file commit.
387
 
            if len(self.parents) > 1 and self.exclude:
388
 
                raise CannotCommitSelectedFileMerge(self.exclude)
389
 
 
390
 
            # Collect the changes
391
 
            self._set_progress_stage("Collecting changes", counter=True)
392
 
            self._lossy = lossy
393
 
            self.builder = self.branch.get_commit_builder(
394
 
                self.parents, self.config_stack, timestamp, timezone, committer,
395
 
                self.revprops, rev_id, lossy=lossy)
396
 
 
397
 
            if self.builder.updates_branch and self.bound_branch:
398
 
                self.builder.abort()
399
 
                raise AssertionError(
400
 
                    "bound branches not supported for commit builders "
401
 
                    "that update the branch")
402
 
 
 
255
            # setup the bound branch variables as needed.
 
256
            self._check_bound_branch()
 
257
 
 
258
            # check for out of date working trees
403
259
            try:
404
 
                # find the location being committed to
405
 
                if self.bound_branch:
406
 
                    master_location = self.master_branch.base
407
 
                else:
408
 
                    master_location = self.branch.base
409
 
 
410
 
                # report the start of the commit
411
 
                self.reporter.started(new_revno, self.rev_id, master_location)
412
 
 
413
 
                self._update_builder_with_changes()
414
 
                self._check_pointless()
415
 
 
416
 
                # TODO: Now the new inventory is known, check for conflicts.
417
 
                # ADHB 2006-08-08: If this is done, populate_new_inv should not add
418
 
                # weave lines, because nothing should be recorded until it is known
419
 
                # that commit will succeed.
420
 
                self._set_progress_stage("Saving data locally")
421
 
                self.builder.finish_inventory()
422
 
 
423
 
                # Prompt the user for a commit message if none provided
424
 
                message = message_callback(self)
425
 
                self.message = message
426
 
 
427
 
                # Add revision data to the local branch
428
 
                self.rev_id = self.builder.commit(self.message)
429
 
 
430
 
            except Exception:
431
 
                mutter("aborting commit write group because of exception:")
432
 
                trace.log_exception_quietly()
433
 
                self.builder.abort()
434
 
                raise
435
 
 
436
 
            self._update_branches(old_revno, old_revid, new_revno)
437
 
 
438
 
            # Make the working tree be up to date with the branch. This
439
 
            # includes automatic changes scheduled to be made to the tree, such
440
 
            # as updating its basis and unversioning paths that were missing.
441
 
            self.work_tree.unversion(self.deleted_paths)
442
 
            self._set_progress_stage("Updating the working tree")
443
 
            self.work_tree.update_basis_by_delta(self.rev_id,
444
 
                                                 self.builder.get_basis_delta())
445
 
            self.reporter.completed(new_revno, self.rev_id)
446
 
            self._process_post_hooks(old_revno, new_revno)
447
 
            return self.rev_id
448
 
 
449
 
    def _update_branches(self, old_revno, old_revid, new_revno):
450
 
        """Update the master and local branch to the new revision.
451
 
 
452
 
        This will try to make sure that the master branch is updated
453
 
        before the local branch.
454
 
 
455
 
        :param old_revno: Revision number of master branch before the
456
 
            commit
457
 
        :param old_revid: Tip of master branch before the commit
458
 
        :param new_revno: Revision number of the new commit
459
 
        """
460
 
        if not self.builder.updates_branch:
461
 
            self._process_pre_hooks(old_revno, new_revno)
462
 
 
463
 
            # Upload revision data to the master.
 
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
 
273
            else:
 
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
 
 
313
            self._check_pointless()
 
314
 
 
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.
 
318
            # ADHB 2006-08-08: If this is done, populate_new_inv should not add
 
319
            # weave lines, because nothing should be recorded until it is known
 
320
            # that commit will succeed.
 
321
            self.builder.finish_inventory()
 
322
            self._emit_progress_update()
 
323
            message = message_callback(self)
 
324
            assert isinstance(message, unicode), type(message)
 
325
            self.message = message
 
326
            self._escape_commit_message()
 
327
 
 
328
            self.rev_id = self.builder.commit(self.message)
 
329
            self._emit_progress_update()
 
330
            # revision data is in the local branch now.
 
331
            
 
332
            # upload revision data to the master.
464
333
            # this will propagate merged revisions too if needed.
465
334
            if self.bound_branch:
466
 
                self._set_progress_stage("Uploading data to master branch")
467
 
                # 'commit' to the master first so a timeout here causes the
468
 
                # local branch to be out of date
469
 
                (new_revno, self.rev_id) = self.master_branch.import_last_revision_info_and_tags(
470
 
                    self.branch, new_revno, self.rev_id, lossy=self._lossy)
471
 
                if self._lossy:
472
 
                    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)
473
342
 
474
343
            # and now do the commit locally.
475
 
            if new_revno is None:
476
 
                # Keep existing behaviour around ghosts
477
 
                new_revno = 1
478
344
            self.branch.set_last_revision_info(new_revno, self.rev_id)
479
 
        else:
480
 
            try:
481
 
                self._process_pre_hooks(old_revno, new_revno)
482
 
            except BaseException:
483
 
                # The commit builder will already have updated the branch,
484
 
                # revert it.
485
 
                self.branch.set_last_revision_info(old_revno, old_revid)
486
 
                raise
487
 
 
488
 
        # Merge local tags to remote
489
 
        if self.bound_branch:
490
 
            self._set_progress_stage("Merging tags to master branch")
491
 
            tag_updates, tag_conflicts = self.branch.tags.merge_to(
492
 
                self.master_branch.tags)
493
 
            if tag_conflicts:
494
 
                warning_lines = ['    ' + name for name, _, _ in tag_conflicts]
495
 
                note(gettext("Conflicting tags in bound branch:\n{0}".format(
496
 
                    "\n".join(warning_lines))))
497
 
 
498
 
    def _select_reporter(self):
499
 
        """Select the CommitReporter to use."""
500
 
        if is_quiet():
501
 
            return NullCommitReporter()
502
 
        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
503
417
 
504
418
    def _check_pointless(self):
505
419
        if self.allow_pointless:
507
421
        # A merge with no effect on files
508
422
        if len(self.parents) > 1:
509
423
            return
510
 
        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()):
511
435
            return
512
436
        raise PointlessCommit()
513
437
 
514
 
    def _check_bound_branch(self, stack, possible_master_transports=None):
 
438
    def _check_bound_branch(self):
515
439
        """Check to see if the local branch is bound.
516
440
 
517
441
        If it is bound, then most of the commit will actually be
522
446
            raise errors.LocalRequiresBoundBranch()
523
447
 
524
448
        if not self.local:
525
 
            self.master_branch = self.branch.get_master_branch(
526
 
                possible_master_transports)
 
449
            self.master_branch = self.branch.get_master_branch()
527
450
 
528
451
        if not self.master_branch:
529
452
            # make this branch the reference branch for out of date checks.
533
456
        # If the master branch is bound, we must fail
534
457
        master_bound_location = self.master_branch.get_bound_location()
535
458
        if master_bound_location:
536
 
            raise errors.CommitToDoubleBoundBranch(
537
 
                self.branch, self.master_branch, master_bound_location)
 
459
            raise errors.CommitToDoubleBoundBranch(self.branch,
 
460
                    self.master_branch, master_bound_location)
538
461
 
539
462
        # TODO: jam 20051230 We could automatically push local
540
463
        #       commits to the remote branch if they would fit.
541
464
        #       But for now, just require remote to be identical
542
465
        #       to local.
543
 
 
 
466
        
544
467
        # Make sure the local branch is identical to the master
545
 
        master_revid = self.master_branch.last_revision()
546
 
        local_revid = self.branch.last_revision()
547
 
        if local_revid != master_revid:
 
468
        master_info = self.master_branch.last_revision_info()
 
469
        local_info = self.branch.last_revision_info()
 
470
        if local_info != master_info:
548
471
            raise errors.BoundBranchOutOfDate(self.branch,
549
 
                                              self.master_branch)
 
472
                    self.master_branch)
550
473
 
551
474
        # Now things are ready to change the master branch
552
475
        # so grab the lock
553
476
        self.bound_branch = self.branch
554
 
        stack.enter_context(self.master_branch.lock_write())
555
 
 
556
 
    def _check_out_of_date_tree(self):
557
 
        """Check that the working tree is up to date.
558
 
 
559
 
        :return: old_revision_number, old_revision_id, new_revision_number
560
 
            tuple
 
477
        self.master_branch.lock_write()
 
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.
561
510
        """
562
 
        try:
563
 
            first_tree_parent = self.work_tree.get_parent_ids()[0]
564
 
        except IndexError:
565
 
            # if there are no parents, treat our parent as 'None'
566
 
            # this is so that we still consider the master branch
567
 
            # - in a checkout scenario the tree may have no
568
 
            # parents but the branch may do.
569
 
            first_tree_parent = breezy.revision.NULL_REVISION
570
 
        if (self.master_branch._format.stores_revno() or
571
 
                self.config_stack.get('calculate_revnos')):
572
 
            try:
573
 
                old_revno, master_last = self.master_branch.last_revision_info()
574
 
            except errors.UnsupportedOperation:
575
 
                master_last = self.master_branch.last_revision()
576
 
                old_revno = self.branch.revision_id_to_revno(master_last)
577
 
        else:
578
 
            master_last = self.master_branch.last_revision()
579
 
            old_revno = None
580
 
        if master_last != first_tree_parent:
581
 
            if master_last != breezy.revision.NULL_REVISION:
582
 
                raise errors.OutOfDateTree(self.work_tree)
583
 
        if (old_revno is not None and
584
 
                self.branch.repository.has_revision(first_tree_parent)):
585
 
            new_revno = old_revno + 1
586
 
        else:
587
 
            # ghost parents never appear in revision history.
588
 
            new_revno = None
589
 
        return old_revno, master_last, new_revno
590
 
 
591
 
    def _process_pre_hooks(self, old_revno, new_revno):
592
 
        """Process any registered pre commit hooks."""
593
 
        self._set_progress_stage("Running pre_commit hooks")
594
 
        self._process_hooks("pre_commit", old_revno, new_revno)
595
 
 
596
 
    def _process_post_hooks(self, old_revno, new_revno):
597
 
        """Process any registered post commit hooks."""
598
 
        # Process the post commit hooks, if any
599
 
        self._set_progress_stage("Running post_commit hooks")
600
 
        # old style commit hooks - should be deprecated ? (obsoleted in
601
 
        # 0.15^H^H^H^H 2.5.0)
602
 
        post_commit = self.config_stack.get('post_commit')
603
 
        if post_commit is not None:
604
 
            hooks = post_commit.split(' ')
605
 
            # this would be nicer with twisted.python.reflect.namedAny
606
 
            for hook in hooks:
607
 
                result = eval(hook + '(branch, rev_id)',
608
 
                              {'branch': self.branch,
609
 
                               'breezy': breezy,
610
 
                               'rev_id': self.rev_id})
611
 
        # process new style post commit hooks
612
 
        self._process_hooks("post_commit", old_revno, new_revno)
613
 
 
614
 
    def _process_hooks(self, hook_name, old_revno, new_revno):
615
 
        if not Branch.hooks[hook_name]:
616
 
            return
617
 
 
618
 
        # new style commit hooks:
619
511
        if not self.bound_branch:
620
 
            hook_master = self.branch
621
 
            hook_local = None
622
 
        else:
623
 
            hook_master = self.master_branch
624
 
            hook_local = self.branch
625
 
        # With bound branches, when the master is behind the local branch,
626
 
        # the 'old_revno' and old_revid values here are incorrect.
627
 
        # XXX: FIXME ^. RBC 20060206
628
 
        if self.parents:
629
 
            old_revid = self.parents[0]
630
 
        else:
631
 
            old_revid = breezy.revision.NULL_REVISION
632
 
 
633
 
        if hook_name == "pre_commit":
634
 
            future_tree = self.builder.revision_tree()
635
 
            tree_delta = future_tree.changes_from(self.basis_tree,
636
 
                                                  include_root=True)
637
 
 
638
 
        for hook in Branch.hooks[hook_name]:
639
 
            # show the running hook in the progress bar. As hooks may
640
 
            # end up doing nothing (e.g. because they are not configured by
641
 
            # the user) this is still showing progress, not showing overall
642
 
            # actions - its up to each plugin to show a UI if it want's to
643
 
            # (such as 'Emailing diff to foo@example.com').
644
 
            self.pb_stage_name = "Running %s hooks [%s]" % \
645
 
                (hook_name, Branch.hooks.get_hook_name(hook))
646
 
            self._emit_progress()
647
 
            if 'hooks' in debug.debug_flags:
648
 
                mutter("Invoking commit hook: %r", hook)
649
 
            if hook_name == "post_commit":
650
 
                hook(hook_local, hook_master, old_revno, old_revid, new_revno,
651
 
                     self.rev_id)
652
 
            elif hook_name == "pre_commit":
653
 
                hook(hook_local, hook_master,
654
 
                     old_revno, old_revid, new_revno, self.rev_id,
655
 
                     tree_delta, future_tree)
656
 
 
657
 
    def _update_builder_with_changes(self):
658
 
        """Update the commit builder with the data about what has changed.
659
 
        """
660
 
        specific_files = self.specific_files
661
 
        mutter("Selecting files for commit with filter %r", specific_files)
662
 
 
663
 
        self._check_strict()
664
 
        iter_changes = self.work_tree.iter_changes(
665
 
            self.basis_tree, specific_files=specific_files)
666
 
        if self.exclude:
667
 
            iter_changes = filter_excluded(iter_changes, self.exclude)
668
 
        iter_changes = self._filter_iter_changes(iter_changes)
669
 
        for path, fs_hash in self.builder.record_iter_changes(
670
 
                self.work_tree, self.basis_revid, iter_changes):
671
 
            self.work_tree._observed_sha1(path, fs_hash)
672
 
 
673
 
    def _filter_iter_changes(self, iter_changes):
674
 
        """Process iter_changes.
675
 
 
676
 
        This method reports on the changes in iter_changes to the user, and
677
 
        converts 'missing' entries in the iter_changes iterator to 'deleted'
678
 
        entries. 'missing' entries have their
679
 
 
680
 
        :param iter_changes: An iter_changes to process.
681
 
        :return: A generator of changes.
682
 
        """
683
 
        reporter = self.reporter
684
 
        report_changes = reporter.is_verbose()
685
 
        deleted_paths = []
686
 
        for change in iter_changes:
687
 
            if report_changes:
688
 
                old_path = change.path[0]
689
 
                new_path = change.path[1]
690
 
                versioned = change.versioned[1]
691
 
            kind = change.kind[1]
692
 
            versioned = change.versioned[1]
693
 
            if kind is None and versioned:
694
 
                # 'missing' path
695
 
                if report_changes:
696
 
                    reporter.missing(new_path)
697
 
                if change.kind[0] == 'symlink' and not self.work_tree.supports_symlinks():
698
 
                    trace.warning('Ignoring "%s" as symlinks are not '
699
 
                                  'supported on this filesystem.' % (change.path[0],))
 
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
700
645
                    continue
701
 
                deleted_paths.append(change.path[1])
702
 
                # Reset the new path (None) and new versioned flag (False)
703
 
                change = change.discard_new()
704
 
                new_path = change.path[1]
705
 
                versioned = False
706
 
            elif kind == 'tree-reference':
707
 
                if self.recursive == 'down':
708
 
                    self._commit_nested_tree(change.path[1])
709
 
            if change.versioned[0] or change.versioned[1]:
710
 
                yield change
711
 
                if report_changes:
712
 
                    if new_path is None:
713
 
                        reporter.deleted(old_path)
714
 
                    elif old_path is None:
715
 
                        reporter.snapshot_change(gettext('added'), new_path)
716
 
                    elif old_path != new_path:
717
 
                        reporter.renamed(gettext('renamed'),
718
 
                                         old_path, new_path)
719
 
                    else:
720
 
                        if (new_path
721
 
                                or self.work_tree.branch.repository._format.rich_root_data):
722
 
                            # Don't report on changes to '' in non rich root
723
 
                            # repositories.
724
 
                            reporter.snapshot_change(
725
 
                                gettext('modified'), new_path)
726
 
            self._next_progress_entry()
727
 
        # Unversion files that were found to be deleted
728
 
        self.deleted_paths = deleted_paths
729
 
 
730
 
    def _check_strict(self):
731
 
        # XXX: when we use iter_changes this would likely be faster if
732
 
        # iter_changes would check for us (even in the presence of
733
 
        # selected_files).
734
 
        if self.strict:
735
 
            # raise an exception as soon as we find a single unknown.
736
 
            for unknown in self.work_tree.unknowns():
737
 
                raise StrictCommitFailed()
738
 
 
739
 
    def _commit_nested_tree(self, path):
740
 
        "Commit a nested tree."
741
 
        sub_tree = self.work_tree.get_nested_tree(path)
742
 
        # FIXME: be more comprehensive here:
743
 
        # this works when both trees are in --trees repository,
744
 
        # but when both are bound to a different repository,
745
 
        # it fails; a better way of approaching this is to
746
 
        # finally implement the explicit-caches approach design
747
 
        # a while back - RBC 20070306.
748
 
        if sub_tree.branch.repository.has_same_location(
749
 
                self.work_tree.branch.repository):
750
 
            sub_tree.branch.repository = \
751
 
                self.work_tree.branch.repository
752
 
        try:
753
 
            return sub_tree.commit(message=None, revprops=self.revprops,
754
 
                                   recursive=self.recursive,
755
 
                                   message_callback=self.message_callback,
756
 
                                   timestamp=self.timestamp,
757
 
                                   timezone=self.timezone,
758
 
                                   committer=self.committer,
759
 
                                   allow_pointless=self.allow_pointless,
760
 
                                   strict=self.strict, verbose=self.verbose,
761
 
                                   local=self.local, reporter=self.reporter)
762
 
        except PointlessCommit:
763
 
            return self.work_tree.get_reference_revision(path)
764
 
 
765
 
    def _set_progress_stage(self, name, counter=False):
766
 
        """Set the progress stage and emit an update to the progress bar."""
767
 
        self.pb_stage_name = name
768
 
        self.pb_stage_count += 1
769
 
        if counter:
770
 
            self.pb_entries_count = 0
771
 
        else:
772
 
            self.pb_entries_count = None
773
 
        self._emit_progress()
774
 
 
775
 
    def _next_progress_entry(self):
776
 
        """Emit an update to the progress bar and increment the entry count."""
777
 
        self.pb_entries_count += 1
778
 
        self._emit_progress()
779
 
 
780
 
    def _emit_progress(self):
781
 
        if self.pb_entries_count is not None:
782
 
            text = gettext("{0} [{1}] - Stage").format(self.pb_stage_name,
783
 
                                                       self.pb_entries_count)
784
 
        else:
785
 
            text = gettext("%s - Stage") % (self.pb_stage_name, )
786
 
        self.pb.update(text, self.pb_stage_count, self.pb_stage_total)
 
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