← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: John Arbash Meinel
  • Date: 2008-09-26 22:14:42 UTC
  • mto: This revision was merged to the branch mainline in revision 3747.
  • Revision ID: john@arbash-meinel.com-20080926221442-3r67j99sr9rwe9w0
Make message optional, don't check the memory flag directly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commit.py
16
16
 
17
17
 
18
18
# The newly committed revision is going to have a shape corresponding
19
 
# to that of the working inventory.  Files that are not in the
 
19
# to that of the working tree.  Files that are not in the
20
20
# working tree and that were in the predecessor are reported as
21
21
# removed --- this can include files that were either removed from the
22
22
# inventory or deleted in the working tree.  If they were only
25
25
# We then consider the remaining entries, which will be in the new
26
26
# version.  Directory entries are simply copied across.  File entries
27
27
# must be checked to see if a new version of the file should be
28
 
# recorded.  For each parent revision inventory, we check to see what
 
28
# recorded.  For each parent revision tree, we check to see what
29
29
# version of the file was present.  If the file was present in at
30
30
# least one tree, and if it was the same version in all the trees,
31
31
# then we can just refer to that version.  Otherwise, a new version
59
59
from bzrlib import (
60
60
    debug,
61
61
    errors,
62
 
    inventory,
 
62
    revision,
63
63
    tree,
64
64
    )
65
65
from bzrlib.branch import Branch
68
68
                           ConflictsInTree,
69
69
                           StrictCommitFailed
70
70
                           )
71
 
from bzrlib.osutils import (kind_marker, isdir,isfile, is_inside_any, 
 
71
from bzrlib.osutils import (kind_marker, isdir,isfile, is_inside_any,
72
72
                            is_inside_or_parent_of_any,
73
 
                            quotefn, sha_file, split_lines)
 
73
                            minimum_path_selection,
 
74
                            quotefn, sha_file, split_lines,
 
75
                            splitpath,
 
76
                            )
74
77
from bzrlib.testament import Testament
75
 
from bzrlib.trace import mutter, note, warning
 
78
from bzrlib.trace import mutter, note, warning, is_quiet
76
79
from bzrlib.xml5 import serializer_v5
77
 
from bzrlib.inventory import Inventory, InventoryEntry
 
80
from bzrlib.inventory import InventoryEntry, make_entry
78
81
from bzrlib import symbol_versioning
79
82
from bzrlib.symbol_versioning import (deprecated_passed,
80
83
        deprecated_function,
81
84
        DEPRECATED_PARAMETER)
82
85
from bzrlib.workingtree import WorkingTree
 
86
from bzrlib.urlutils import unescape_for_display
83
87
import bzrlib.ui
84
88
 
85
89
 
86
90
class NullCommitReporter(object):
87
91
    """I report on progress of a commit."""
88
92
 
 
93
    def started(self, revno, revid, location=None):
 
94
        if location is None:
 
95
            symbol_versioning.warn("As of bzr 1.0 you must pass a location "
 
96
                                   "to started.", DeprecationWarning,
 
97
                                   stacklevel=2)
 
98
        pass
 
99
 
89
100
    def snapshot_change(self, change, path):
90
101
        pass
91
102
 
104
115
    def renamed(self, change, old_path, new_path):
105
116
        pass
106
117
 
 
118
    def is_verbose(self):
 
119
        return False
 
120
 
107
121
 
108
122
class ReportCommitToLog(NullCommitReporter):
109
123
 
121
135
            return
122
136
        self._note("%s %s", change, path)
123
137
 
 
138
    def started(self, revno, rev_id, location=None):
 
139
        if location is not None:
 
140
            location = ' to: ' + unescape_for_display(location, 'utf-8')
 
141
        else:
 
142
            # When started was added, location was only made optional by
 
143
            # accident.  Matt Nordhoff 20071129
 
144
            symbol_versioning.warn("As of bzr 1.0 you must pass a location "
 
145
                                   "to started.", DeprecationWarning,
 
146
                                   stacklevel=2)
 
147
            location = ''
 
148
        self._note('Committing%s', location)
 
149
 
124
150
    def completed(self, revno, rev_id):
125
151
        self._note('Committed revision %d.', revno)
126
 
    
 
152
 
127
153
    def deleted(self, file_id):
128
154
        self._note('deleted %s', file_id)
129
155
 
136
162
    def renamed(self, change, old_path, new_path):
137
163
        self._note('%s %s => %s', change, old_path, new_path)
138
164
 
 
165
    def is_verbose(self):
 
166
        return True
 
167
 
139
168
 
140
169
class Commit(object):
141
170
    """Task of committing a new revision.
152
181
    def __init__(self,
153
182
                 reporter=None,
154
183
                 config=None):
155
 
        if reporter is not None:
156
 
            self.reporter = reporter
157
 
        else:
158
 
            self.reporter = NullCommitReporter()
 
184
        """Create a Commit object.
 
185
 
 
186
        :param reporter: the default reporter to use or None to decide later
 
187
        """
 
188
        self.reporter = reporter
159
189
        self.config = config
160
 
        
 
190
 
161
191
    def commit(self,
162
192
               message=None,
163
193
               timestamp=None,
174
204
               reporter=None,
175
205
               config=None,
176
206
               message_callback=None,
177
 
               recursive='down'):
 
207
               recursive='down',
 
208
               exclude=None):
178
209
        """Commit working copy as a new revision.
179
210
 
180
211
        :param message: the commit message (it or message_callback is required)
198
229
 
199
230
        :param revprops: Properties for new revision
200
231
        :param local: Perform a local only commit.
 
232
        :param reporter: the reporter to use or None for the default
 
233
        :param verbose: if True and the reporter is not None, report everything
201
234
        :param recursive: If set to 'down', commit in any subtrees that have
202
235
            pending changes of any sort during this commit.
 
236
        :param exclude: None or a list of relative paths to exclude from the
 
237
            commit. Pending changes to excluded files will be ignored by the
 
238
            commit. 
203
239
        """
204
240
        mutter('preparing to commit')
205
241
 
221
257
                               " parameter is required for commit().")
222
258
 
223
259
        self.bound_branch = None
 
260
        self.any_entries_changed = False
 
261
        self.any_entries_deleted = False
 
262
        if exclude is not None:
 
263
            self.exclude = sorted(
 
264
                minimum_path_selection(exclude))
 
265
        else:
 
266
            self.exclude = []
224
267
        self.local = local
225
268
        self.master_branch = None
226
269
        self.master_locked = False
 
270
        self.recursive = recursive
227
271
        self.rev_id = None
228
 
        self.specific_files = specific_files
 
272
        if specific_files is not None:
 
273
            self.specific_files = sorted(
 
274
                minimum_path_selection(specific_files))
 
275
        else:
 
276
            self.specific_files = None
 
277
        self.specific_file_ids = None
229
278
        self.allow_pointless = allow_pointless
230
 
        self.recursive = recursive
231
279
        self.revprops = revprops
232
280
        self.message_callback = message_callback
233
281
        self.timestamp = timestamp
235
283
        self.committer = committer
236
284
        self.strict = strict
237
285
        self.verbose = verbose
238
 
 
239
 
        if reporter is None and self.reporter is None:
240
 
            self.reporter = NullCommitReporter()
241
 
        elif reporter is not None:
242
 
            self.reporter = reporter
 
286
        # accumulates an inventory delta to the basis entry, so we can make
 
287
        # just the necessary updates to the workingtree's cached basis.
 
288
        self._basis_delta = []
243
289
 
244
290
        self.work_tree.lock_write()
245
291
        self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
292
        self.basis_revid = self.work_tree.last_revision()
246
293
        self.basis_tree = self.work_tree.basis_tree()
247
294
        self.basis_tree.lock_read()
248
295
        try:
254
301
            self._check_bound_branch()
255
302
 
256
303
            # Check that the working tree is up to date
257
 
            old_revno,new_revno = self._check_out_of_date_tree()
 
304
            old_revno, new_revno = self._check_out_of_date_tree()
258
305
 
259
 
            if strict:
260
 
                # raise an exception as soon as we find a single unknown.
261
 
                for unknown in self.work_tree.unknowns():
262
 
                    raise StrictCommitFailed()
263
 
                   
 
306
            # Complete configuration setup
 
307
            if reporter is not None:
 
308
                self.reporter = reporter
 
309
            elif self.reporter is None:
 
310
                self.reporter = self._select_reporter()
264
311
            if self.config is None:
265
312
                self.config = self.branch.get_config()
266
313
 
267
314
            # If provided, ensure the specified files are versioned
268
 
            if specific_files is not None:
269
 
                # Note: We don't actually need the IDs here. This routine
270
 
                # is being called because it raises PathNotVerisonedError
271
 
                # as a side effect of finding the IDs.
 
315
            if self.specific_files is not None:
 
316
                # Note: This routine is being called because it raises
 
317
                # PathNotVersionedError as a side effect of finding the IDs. We
 
318
                # later use the ids we found as input to the working tree
 
319
                # inventory iterator, so we only consider those ids rather than
 
320
                # examining the whole tree again.
272
321
                # XXX: Dont we have filter_unversioned to do this more
273
322
                # cheaply?
274
 
                tree.find_ids_across_trees(specific_files,
275
 
                                           [self.basis_tree, self.work_tree])
 
323
                self.specific_file_ids = tree.find_ids_across_trees(
 
324
                    specific_files, [self.basis_tree, self.work_tree])
276
325
 
277
326
            # Setup the progress bar. As the number of files that need to be
278
327
            # committed in unknown, progress is reported as stages.
280
329
            # information in the progress bar during the relevant stages.
281
330
            self.pb_stage_name = ""
282
331
            self.pb_stage_count = 0
283
 
            self.pb_stage_total = 4
 
332
            self.pb_stage_total = 5
284
333
            if self.bound_branch:
285
334
                self.pb_stage_total += 1
286
335
            self.pb.show_pct = False
289
338
            self.pb.show_count = True
290
339
            self.pb.show_bar = True
291
340
 
 
341
            self.basis_inv = self.basis_tree.inventory
 
342
            self._gather_parents()
292
343
            # After a merge, a selected file commit is not supported.
293
344
            # See 'bzr help merge' for an explanation as to why.
294
 
            self.basis_inv = self.basis_tree.inventory
295
 
            self._gather_parents()
296
345
            if len(self.parents) > 1 and self.specific_files:
297
346
                raise errors.CannotCommitSelectedFileMerge(self.specific_files)
298
 
            
 
347
            # Excludes are a form of selected file commit.
 
348
            if len(self.parents) > 1 and self.exclude:
 
349
                raise errors.CannotCommitSelectedFileMerge(self.exclude)
 
350
 
299
351
            # Collect the changes
300
 
            self._emit_progress_set_stage("Collecting changes", show_entries=True)
 
352
            self._set_progress_stage("Collecting changes",
 
353
                    entries_title="Directory")
301
354
            self.builder = self.branch.get_commit_builder(self.parents,
302
355
                self.config, timestamp, timezone, committer, revprops, rev_id)
303
 
            self._update_builder_with_changes()
304
 
            self._check_pointless()
305
 
 
306
 
            # TODO: Now the new inventory is known, check for conflicts.
307
 
            # ADHB 2006-08-08: If this is done, populate_new_inv should not add
308
 
            # weave lines, because nothing should be recorded until it is known
309
 
            # that commit will succeed.
310
 
            self._emit_progress_set_stage("Saving data locally")
311
 
            self.builder.finish_inventory()
312
 
 
313
 
            # Prompt the user for a commit message if none provided
314
 
            message = message_callback(self)
315
 
            assert isinstance(message, unicode), type(message)
316
 
            self.message = message
317
 
            self._escape_commit_message()
318
 
 
319
 
            # Add revision data to the local branch
320
 
            self.rev_id = self.builder.commit(self.message)
321
356
            
 
357
            try:
 
358
                # find the location being committed to
 
359
                if self.bound_branch:
 
360
                    master_location = self.master_branch.base
 
361
                else:
 
362
                    master_location = self.branch.base
 
363
 
 
364
                # report the start of the commit
 
365
                self.reporter.started(new_revno, self.rev_id, master_location)
 
366
 
 
367
                self._update_builder_with_changes()
 
368
                self._report_and_accumulate_deletes()
 
369
                self._check_pointless()
 
370
 
 
371
                # TODO: Now the new inventory is known, check for conflicts.
 
372
                # ADHB 2006-08-08: If this is done, populate_new_inv should not add
 
373
                # weave lines, because nothing should be recorded until it is known
 
374
                # that commit will succeed.
 
375
                self._set_progress_stage("Saving data locally")
 
376
                self.builder.finish_inventory()
 
377
 
 
378
                # Prompt the user for a commit message if none provided
 
379
                message = message_callback(self)
 
380
                self.message = message
 
381
                self._escape_commit_message()
 
382
 
 
383
                # Add revision data to the local branch
 
384
                self.rev_id = self.builder.commit(self.message)
 
385
 
 
386
            except:
 
387
                self.builder.abort()
 
388
                raise
 
389
 
 
390
            self._process_pre_hooks(old_revno, new_revno)
 
391
 
322
392
            # Upload revision data to the master.
323
393
            # this will propagate merged revisions too if needed.
324
394
            if self.bound_branch:
325
 
                self._emit_progress_set_stage("Uploading data to master branch")
326
 
                self.master_branch.repository.fetch(self.branch.repository,
327
 
                                                    revision_id=self.rev_id)
 
395
                if not self.master_branch.repository.has_same_location(
 
396
                        self.branch.repository):
 
397
                    self._set_progress_stage("Uploading data to master branch")
 
398
                    self.master_branch.repository.fetch(self.branch.repository,
 
399
                        revision_id=self.rev_id)
328
400
                # now the master has the revision data
329
401
                # 'commit' to the master first so a timeout here causes the
330
402
                # local branch to be out of date
335
407
            self.branch.set_last_revision_info(new_revno, self.rev_id)
336
408
 
337
409
            # Make the working tree up to date with the branch
338
 
            self._emit_progress_set_stage("Updating the working tree")
339
 
            rev_tree = self.builder.revision_tree()
340
 
            self.work_tree.set_parent_trees([(self.rev_id, rev_tree)])
 
410
            self._set_progress_stage("Updating the working tree")
 
411
            self.work_tree.update_basis_by_delta(self.rev_id,
 
412
                 self._basis_delta)
341
413
            self.reporter.completed(new_revno, self.rev_id)
342
 
            self._process_hooks(old_revno, new_revno)
 
414
            self._process_post_hooks(old_revno, new_revno)
343
415
        finally:
344
416
            self._cleanup()
345
417
        return self.rev_id
346
418
 
347
 
    def _any_real_changes(self):
348
 
        """Are there real changes between new_inventory and basis?
349
 
 
350
 
        For trees without rich roots, inv.root.revision changes every commit.
351
 
        But if that is the only change, we want to treat it as though there
352
 
        are *no* changes.
353
 
        """
354
 
        new_entries = self.builder.new_inventory.iter_entries()
355
 
        basis_entries = self.basis_inv.iter_entries()
356
 
        new_path, new_root_ie = new_entries.next()
357
 
        basis_path, basis_root_ie = basis_entries.next()
358
 
 
359
 
        # This is a copy of InventoryEntry.__eq__ only leaving out .revision
360
 
        def ie_equal_no_revision(this, other):
361
 
            return ((this.file_id == other.file_id)
362
 
                    and (this.name == other.name)
363
 
                    and (this.symlink_target == other.symlink_target)
364
 
                    and (this.text_sha1 == other.text_sha1)
365
 
                    and (this.text_size == other.text_size)
366
 
                    and (this.text_id == other.text_id)
367
 
                    and (this.parent_id == other.parent_id)
368
 
                    and (this.kind == other.kind)
369
 
                    and (this.executable == other.executable)
370
 
                    and (this.reference_revision == other.reference_revision)
371
 
                    )
372
 
        if not ie_equal_no_revision(new_root_ie, basis_root_ie):
373
 
            return True
374
 
 
375
 
        for new_ie, basis_ie in zip(new_entries, basis_entries):
376
 
            if new_ie != basis_ie:
377
 
                return True
378
 
 
379
 
        # No actual changes present
380
 
        return False
 
419
    def _select_reporter(self):
 
420
        """Select the CommitReporter to use."""
 
421
        if is_quiet():
 
422
            return NullCommitReporter()
 
423
        return ReportCommitToLog()
381
424
 
382
425
    def _check_pointless(self):
383
426
        if self.allow_pointless:
385
428
        # A merge with no effect on files
386
429
        if len(self.parents) > 1:
387
430
            return
388
 
        # work around the fact that a newly-initted tree does differ from its
389
 
        # basis
390
 
        if len(self.basis_inv) == 0 and len(self.builder.new_inventory) == 1:
 
431
        # TODO: we could simplify this by using self._basis_delta.
 
432
 
 
433
        # The initial commit adds a root directory, but this in itself is not
 
434
        # a worthwhile commit.
 
435
        if (self.basis_revid == revision.NULL_REVISION and
 
436
            len(self.builder.new_inventory) == 1):
391
437
            raise PointlessCommit()
392
 
        # Shortcut, if the number of entries changes, then we obviously have
393
 
        # a change
394
 
        if len(self.builder.new_inventory) != len(self.basis_inv):
395
 
            return
396
438
        # If length == 1, then we only have the root entry. Which means
397
439
        # that there is no real difference (only the root could be different)
398
 
        if (len(self.builder.new_inventory) != 1 and self._any_real_changes()):
 
440
        # unless deletes occured, in which case the length is irrelevant.
 
441
        if (self.any_entries_deleted or 
 
442
            (len(self.builder.new_inventory) != 1 and
 
443
             self.any_entries_changed)):
399
444
            return
400
445
        raise PointlessCommit()
401
446
 
465
510
            new_revno = 1
466
511
        return old_revno,new_revno
467
512
 
468
 
    def _process_hooks(self, old_revno, new_revno):
469
 
        """Process any registered commit hooks."""
 
513
    def _process_pre_hooks(self, old_revno, new_revno):
 
514
        """Process any registered pre commit hooks."""
 
515
        self._set_progress_stage("Running pre_commit hooks")
 
516
        self._process_hooks("pre_commit", old_revno, new_revno)
 
517
 
 
518
    def _process_post_hooks(self, old_revno, new_revno):
 
519
        """Process any registered post commit hooks."""
470
520
        # Process the post commit hooks, if any
471
 
        self._emit_progress_set_stage("Running post commit hooks")
 
521
        self._set_progress_stage("Running post_commit hooks")
472
522
        # old style commit hooks - should be deprecated ? (obsoleted in
473
523
        # 0.15)
474
524
        if self.config.post_commit() is not None:
479
529
                              {'branch':self.branch,
480
530
                               'bzrlib':bzrlib,
481
531
                               'rev_id':self.rev_id})
 
532
        # process new style post commit hooks
 
533
        self._process_hooks("post_commit", old_revno, new_revno)
 
534
 
 
535
    def _process_hooks(self, hook_name, old_revno, new_revno):
 
536
        if not Branch.hooks[hook_name]:
 
537
            return
 
538
        
482
539
        # new style commit hooks:
483
540
        if not self.bound_branch:
484
541
            hook_master = self.branch
493
550
            old_revid = self.parents[0]
494
551
        else:
495
552
            old_revid = bzrlib.revision.NULL_REVISION
496
 
        for hook in Branch.hooks['post_commit']:
 
553
        
 
554
        if hook_name == "pre_commit":
 
555
            future_tree = self.builder.revision_tree()
 
556
            tree_delta = future_tree.changes_from(self.basis_tree,
 
557
                                             include_root=True)
 
558
        
 
559
        for hook in Branch.hooks[hook_name]:
497
560
            # show the running hook in the progress bar. As hooks may
498
561
            # end up doing nothing (e.g. because they are not configured by
499
562
            # the user) this is still showing progress, not showing overall
500
563
            # actions - its up to each plugin to show a UI if it want's to
501
564
            # (such as 'Emailing diff to foo@example.com').
502
 
            self.pb_stage_name = "Running post commit hooks [%s]" % \
503
 
                Branch.hooks.get_hook_name(hook)
 
565
            self.pb_stage_name = "Running %s hooks [%s]" % \
 
566
                (hook_name, Branch.hooks.get_hook_name(hook))
504
567
            self._emit_progress()
505
568
            if 'hooks' in debug.debug_flags:
506
569
                mutter("Invoking commit hook: %r", hook)
507
 
            hook(hook_local, hook_master, old_revno, old_revid, new_revno,
508
 
                self.rev_id)
 
570
            if hook_name == "post_commit":
 
571
                hook(hook_local, hook_master, old_revno, old_revid, new_revno,
 
572
                     self.rev_id)
 
573
            elif hook_name == "pre_commit":
 
574
                hook(hook_local, hook_master,
 
575
                     old_revno, old_revid, new_revno, self.rev_id,
 
576
                     tree_delta, future_tree)
509
577
 
510
578
    def _cleanup(self):
511
579
        """Cleanup any open locks, progress bars etc."""
592
660
        # in bugs like #46635.  Any reason not to use/enhance Tree.changes_from?
593
661
        # ADHB 11-07-2006
594
662
 
 
663
        exclude = self.exclude
 
664
        specific_files = self.specific_files or []
 
665
        mutter("Selecting files for commit with filter %s", specific_files)
 
666
 
 
667
        # Build the new inventory
 
668
        self._populate_from_inventory()
 
669
 
 
670
        # If specific files are selected, then all un-selected files must be
 
671
        # recorded in their previous state. For more details, see
 
672
        # https://lists.ubuntu.com/archives/bazaar/2007q3/028476.html.
 
673
        if specific_files or exclude:
 
674
            for path, old_ie in self.basis_inv.iter_entries():
 
675
                if old_ie.file_id in self.builder.new_inventory:
 
676
                    # already added - skip.
 
677
                    continue
 
678
                if (is_inside_any(specific_files, path)
 
679
                    and not is_inside_any(exclude, path)):
 
680
                    # was inside the selected path, and not excluded - if not
 
681
                    # present it has been deleted so skip.
 
682
                    continue
 
683
                # From here down it was either not selected, or was excluded:
 
684
                if old_ie.kind == 'directory':
 
685
                    self._next_progress_entry()
 
686
                # We preserve the entry unaltered.
 
687
                ie = old_ie.copy()
 
688
                # Note: specific file commits after a merge are currently
 
689
                # prohibited. This test is for sanity/safety in case it's
 
690
                # required after that changes.
 
691
                if len(self.parents) > 1:
 
692
                    ie.revision = None
 
693
                delta, version_recorded = self.builder.record_entry_contents(
 
694
                    ie, self.parent_invs, path, self.basis_tree, None)
 
695
                if version_recorded:
 
696
                    self.any_entries_changed = True
 
697
                if delta: self._basis_delta.append(delta)
 
698
 
 
699
    def _report_and_accumulate_deletes(self):
 
700
        # XXX: Could the list of deleted paths and ids be instead taken from
 
701
        # _populate_from_inventory?
 
702
        deleted_ids = set(self.basis_inv._byid.keys()) - \
 
703
            set(self.builder.new_inventory._byid.keys())
 
704
        if deleted_ids:
 
705
            self.any_entries_deleted = True
 
706
            deleted = [(self.basis_tree.id2path(file_id), file_id)
 
707
                for file_id in deleted_ids]
 
708
            deleted.sort()
 
709
            # XXX: this is not quite directory-order sorting
 
710
            for path, file_id in deleted:
 
711
                self._basis_delta.append((path, None, file_id, None))
 
712
                self.reporter.deleted(path)
 
713
 
 
714
    def _populate_from_inventory(self):
 
715
        """Populate the CommitBuilder by walking the working tree inventory."""
 
716
        if self.strict:
 
717
            # raise an exception as soon as we find a single unknown.
 
718
            for unknown in self.work_tree.unknowns():
 
719
                raise StrictCommitFailed()
 
720
        
595
721
        specific_files = self.specific_files
596
 
        mutter("Selecting files for commit with filter %s", specific_files)
 
722
        exclude = self.exclude
 
723
        report_changes = self.reporter.is_verbose()
 
724
        deleted_ids = []
 
725
        # A tree of paths that have been deleted. E.g. if foo/bar has been
 
726
        # deleted, then we have {'foo':{'bar':{}}}
 
727
        deleted_paths = {}
 
728
        # XXX: Note that entries may have the wrong kind because the entry does
 
729
        # not reflect the status on disk.
597
730
        work_inv = self.work_tree.inventory
598
 
        assert work_inv.root is not None
599
 
        self.pb_entries_total = len(work_inv)
600
 
 
601
 
        # Check and warn about old CommitBuilders
602
 
        entries = work_inv.iter_entries()
603
 
        if not self.builder.record_root_entry:
604
 
            symbol_versioning.warn('CommitBuilders should support recording'
605
 
                ' the root entry as of bzr 0.10.', DeprecationWarning, 
606
 
                stacklevel=1)
607
 
            self.builder.new_inventory.add(self.basis_inv.root.copy())
608
 
            entries.next()
609
 
 
610
 
        deleted_ids = []
611
 
        deleted_paths = set()
612
 
        for path, new_ie in entries:
613
 
            self._emit_progress_next_entry()
614
 
            file_id = new_ie.file_id
615
 
 
 
731
        # NB: entries will include entries within the excluded ids/paths
 
732
        # because iter_entries_by_dir has no 'exclude' facility today.
 
733
        entries = work_inv.iter_entries_by_dir(
 
734
            specific_file_ids=self.specific_file_ids, yield_parents=True)
 
735
        for path, existing_ie in entries:
 
736
            file_id = existing_ie.file_id
 
737
            name = existing_ie.name
 
738
            parent_id = existing_ie.parent_id
 
739
            kind = existing_ie.kind
 
740
            if kind == 'directory':
 
741
                self._next_progress_entry()
616
742
            # Skip files that have been deleted from the working tree.
617
 
            # The deleted files/directories are also recorded so they
618
 
            # can be explicitly unversioned later. Note that when a
619
 
            # filter of specific files is given, we must only skip/record
620
 
            # deleted files matching that filter.
621
 
            if is_inside_any(deleted_paths, path):
 
743
            # The deleted path ids are also recorded so they can be explicitly
 
744
            # unversioned later.
 
745
            if deleted_paths:
 
746
                path_segments = splitpath(path)
 
747
                deleted_dict = deleted_paths
 
748
                for segment in path_segments:
 
749
                    deleted_dict = deleted_dict.get(segment, None)
 
750
                    if not deleted_dict:
 
751
                        # We either took a path not present in the dict
 
752
                        # (deleted_dict was None), or we've reached an empty
 
753
                        # child dir in the dict, so are now a sub-path.
 
754
                        break
 
755
                else:
 
756
                    deleted_dict = None
 
757
                if deleted_dict is not None:
 
758
                    # the path has a deleted parent, do not add it.
 
759
                    continue
 
760
            if exclude and is_inside_any(exclude, path):
 
761
                # Skip excluded paths. Excluded paths are processed by
 
762
                # _update_builder_with_changes.
622
763
                continue
 
764
            content_summary = self.work_tree.path_content_summary(path)
 
765
            # Note that when a filter of specific files is given, we must only
 
766
            # skip/record deleted files matching that filter.
623
767
            if not specific_files or is_inside_any(specific_files, path):
624
 
                if not self.work_tree.has_filename(path):
625
 
                    deleted_paths.add(path)
 
768
                if content_summary[0] == 'missing':
 
769
                    if not deleted_paths:
 
770
                        # path won't have been split yet.
 
771
                        path_segments = splitpath(path)
 
772
                    deleted_dict = deleted_paths
 
773
                    for segment in path_segments:
 
774
                        deleted_dict = deleted_dict.setdefault(segment, {})
626
775
                    self.reporter.missing(path)
627
776
                    deleted_ids.append(file_id)
628
777
                    continue
629
 
            try:
630
 
                kind = self.work_tree.kind(file_id)
631
 
                if kind == 'tree-reference' and self.recursive == 'down':
632
 
                    # nested tree: commit in it
633
 
                    sub_tree = WorkingTree.open(self.work_tree.abspath(path))
634
 
                    # FIXME: be more comprehensive here:
635
 
                    # this works when both trees are in --trees repository,
636
 
                    # but when both are bound to a different repository,
637
 
                    # it fails; a better way of approaching this is to 
638
 
                    # finally implement the explicit-caches approach design
639
 
                    # a while back - RBC 20070306.
640
 
                    if (sub_tree.branch.repository.bzrdir.root_transport.base
641
 
                        ==
642
 
                        self.work_tree.branch.repository.bzrdir.root_transport.base):
643
 
                        sub_tree.branch.repository = \
644
 
                            self.work_tree.branch.repository
645
 
                    try:
646
 
                        sub_tree.commit(message=None, revprops=self.revprops,
647
 
                            recursive=self.recursive,
648
 
                            message_callback=self.message_callback,
649
 
                            timestamp=self.timestamp, timezone=self.timezone,
650
 
                            committer=self.committer,
651
 
                            allow_pointless=self.allow_pointless,
652
 
                            strict=self.strict, verbose=self.verbose,
653
 
                            local=self.local, reporter=self.reporter)
654
 
                    except errors.PointlessCommit:
655
 
                        pass
656
 
                if kind != new_ie.kind:
657
 
                    new_ie = inventory.make_entry(kind, new_ie.name,
658
 
                                                  new_ie.parent_id, file_id)
659
 
            except errors.NoSuchFile:
660
 
                pass
661
 
            # mutter('check %s {%s}', path, file_id)
662
 
            if (not specific_files or 
663
 
                is_inside_or_parent_of_any(specific_files, path)):
664
 
                    # mutter('%s selected for commit', path)
665
 
                    ie = new_ie.copy()
666
 
                    ie.revision = None
667
 
            else:
668
 
                # mutter('%s not selected for commit', path)
669
 
                if self.basis_inv.has_id(file_id):
670
 
                    ie = self.basis_inv[file_id].copy()
 
778
            # TODO: have the builder do the nested commit just-in-time IF and
 
779
            # only if needed.
 
780
            if content_summary[0] == 'tree-reference':
 
781
                # enforce repository nested tree policy.
 
782
                if (not self.work_tree.supports_tree_reference() or
 
783
                    # repository does not support it either.
 
784
                    not self.branch.repository._format.supports_tree_reference):
 
785
                    content_summary = ('directory',) + content_summary[1:]
 
786
            kind = content_summary[0]
 
787
            # TODO: specific_files filtering before nested tree processing
 
788
            if kind == 'tree-reference':
 
789
                if self.recursive == 'down':
 
790
                    nested_revision_id = self._commit_nested_tree(
 
791
                        file_id, path)
 
792
                    content_summary = content_summary[:3] + (
 
793
                        nested_revision_id,)
671
794
                else:
672
 
                    # this entry is new and not being committed
673
 
                    continue
674
 
            self.builder.record_entry_contents(ie, self.parent_invs, 
675
 
                path, self.work_tree)
676
 
            # describe the nature of the change that has occurred relative to
677
 
            # the basis inventory.
678
 
            if (self.basis_inv.has_id(ie.file_id)):
679
 
                basis_ie = self.basis_inv[ie.file_id]
680
 
            else:
681
 
                basis_ie = None
682
 
            change = ie.describe_change(basis_ie, ie)
683
 
            if change in (InventoryEntry.RENAMED, 
684
 
                InventoryEntry.MODIFIED_AND_RENAMED):
685
 
                old_path = self.basis_inv.id2path(ie.file_id)
686
 
                self.reporter.renamed(change, old_path, path)
687
 
            else:
688
 
                self.reporter.snapshot_change(change, path)
 
795
                    content_summary = content_summary[:3] + (
 
796
                        self.work_tree.get_reference_revision(file_id),)
 
797
 
 
798
            # Record an entry for this item
 
799
            # Note: I don't particularly want to have the existing_ie
 
800
            # parameter but the test suite currently (28-Jun-07) breaks
 
801
            # without it thanks to a unicode normalisation issue. :-(
 
802
            definitely_changed = kind != existing_ie.kind
 
803
            self._record_entry(path, file_id, specific_files, kind, name,
 
804
                parent_id, definitely_changed, existing_ie, report_changes,
 
805
                content_summary)
689
806
 
690
807
        # Unversion IDs that were found to be deleted
691
808
        self.work_tree.unversion(deleted_ids)
692
809
 
693
 
        # If specific files/directories were nominated, it is possible
694
 
        # that some data from outside those needs to be preserved from
695
 
        # the basis tree. For example, if a file x is moved from out of
696
 
        # directory foo into directory bar and the user requests
697
 
        # ``commit foo``, then information about bar/x must also be
698
 
        # recorded.
699
 
        if specific_files:
700
 
            for path, new_ie in self.basis_inv.iter_entries():
701
 
                if new_ie.file_id in work_inv:
702
 
                    continue
703
 
                if is_inside_any(specific_files, path):
704
 
                    continue
705
 
                ie = new_ie.copy()
706
 
                ie.revision = None
707
 
                self.builder.record_entry_contents(ie, self.parent_invs, path,
708
 
                                                   self.basis_tree)
709
 
 
710
 
        # Report what was deleted. We could skip this when no deletes are
711
 
        # detected to gain a performance win, but it arguably serves as a
712
 
        # 'safety check' by informing the user whenever anything disappears.
713
 
        for path, ie in self.basis_inv.iter_entries():
714
 
            if ie.file_id not in self.builder.new_inventory:
715
 
                self.reporter.deleted(path)
716
 
 
717
 
    def _emit_progress_set_stage(self, name, show_entries=False):
 
810
    def _commit_nested_tree(self, file_id, path):
 
811
        "Commit a nested tree."
 
812
        sub_tree = self.work_tree.get_nested_tree(file_id, path)
 
813
        # FIXME: be more comprehensive here:
 
814
        # this works when both trees are in --trees repository,
 
815
        # but when both are bound to a different repository,
 
816
        # it fails; a better way of approaching this is to 
 
817
        # finally implement the explicit-caches approach design
 
818
        # a while back - RBC 20070306.
 
819
        if sub_tree.branch.repository.has_same_location(
 
820
            self.work_tree.branch.repository):
 
821
            sub_tree.branch.repository = \
 
822
                self.work_tree.branch.repository
 
823
        try:
 
824
            return sub_tree.commit(message=None, revprops=self.revprops,
 
825
                recursive=self.recursive,
 
826
                message_callback=self.message_callback,
 
827
                timestamp=self.timestamp, timezone=self.timezone,
 
828
                committer=self.committer,
 
829
                allow_pointless=self.allow_pointless,
 
830
                strict=self.strict, verbose=self.verbose,
 
831
                local=self.local, reporter=self.reporter)
 
832
        except errors.PointlessCommit:
 
833
            return self.work_tree.get_reference_revision(file_id)
 
834
 
 
835
    def _record_entry(self, path, file_id, specific_files, kind, name,
 
836
        parent_id, definitely_changed, existing_ie, report_changes,
 
837
        content_summary):
 
838
        "Record the new inventory entry for a path if any."
 
839
        # mutter('check %s {%s}', path, file_id)
 
840
        # mutter('%s selected for commit', path)
 
841
        if definitely_changed or existing_ie is None:
 
842
            ie = make_entry(kind, name, parent_id, file_id)
 
843
        else:
 
844
            ie = existing_ie.copy()
 
845
            ie.revision = None
 
846
        delta, version_recorded = self.builder.record_entry_contents(ie,
 
847
            self.parent_invs, path, self.work_tree, content_summary)
 
848
        if delta:
 
849
            self._basis_delta.append(delta)
 
850
        if version_recorded:
 
851
            self.any_entries_changed = True
 
852
        if report_changes:
 
853
            self._report_change(ie, path)
 
854
        return ie
 
855
 
 
856
    def _report_change(self, ie, path):
 
857
        """Report a change to the user.
 
858
 
 
859
        The change that has occurred is described relative to the basis
 
860
        inventory.
 
861
        """
 
862
        if (self.basis_inv.has_id(ie.file_id)):
 
863
            basis_ie = self.basis_inv[ie.file_id]
 
864
        else:
 
865
            basis_ie = None
 
866
        change = ie.describe_change(basis_ie, ie)
 
867
        if change in (InventoryEntry.RENAMED, 
 
868
            InventoryEntry.MODIFIED_AND_RENAMED):
 
869
            old_path = self.basis_inv.id2path(ie.file_id)
 
870
            self.reporter.renamed(change, old_path, path)
 
871
        else:
 
872
            self.reporter.snapshot_change(change, path)
 
873
 
 
874
    def _set_progress_stage(self, name, entries_title=None):
718
875
        """Set the progress stage and emit an update to the progress bar."""
719
876
        self.pb_stage_name = name
720
877
        self.pb_stage_count += 1
721
 
        self.pb_entries_show = show_entries
722
 
        if show_entries:
 
878
        self.pb_entries_title = entries_title
 
879
        if entries_title is not None:
723
880
            self.pb_entries_count = 0
724
881
            self.pb_entries_total = '?'
725
882
        self._emit_progress()
726
883
 
727
 
    def _emit_progress_next_entry(self):
728
 
        """Emit an update to the progress bar and increment the file count."""
 
884
    def _next_progress_entry(self):
 
885
        """Emit an update to the progress bar and increment the entry count."""
729
886
        self.pb_entries_count += 1
730
887
        self._emit_progress()
731
888
 
732
889
    def _emit_progress(self):
733
 
        if self.pb_entries_show:
734
 
            text = "%s [Entry %d/%s] - Stage" % (self.pb_stage_name,
735
 
                self.pb_entries_count,str(self.pb_entries_total))
 
890
        if self.pb_entries_title:
 
891
            if self.pb_entries_total == '?':
 
892
                text = "%s [%s %d] - Stage" % (self.pb_stage_name,
 
893
                    self.pb_entries_title, self.pb_entries_count)
 
894
            else:
 
895
                text = "%s [%s %d/%s] - Stage" % (self.pb_stage_name,
 
896
                    self.pb_entries_title, self.pb_entries_count,
 
897
                    str(self.pb_entries_total))
736
898
        else:
737
899
            text = "%s - Stage" % (self.pb_stage_name)
738
900
        self.pb.update(text, self.pb_stage_count, self.pb_stage_total)