/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: Vincent Ladeuil
  • Date: 2011-11-24 10:47:43 UTC
  • mto: (6321.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6322.
  • Revision ID: v.ladeuil+lp@free.fr-20111124104743-rxqwhmzqu5k17f24
First cut at a working plugin to avoid conflicts in .po files by shelling out to msgmerge.

Show diffs side-by-side

added added

removed removed

Lines of Context:
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
 
17
18
# The newly committed revision is going to have a shape corresponding
18
19
# to that of the working tree.  Files that are not in the
19
20
# working tree and that were in the predecessor are reported as
48
49
# TODO: Change the parameter 'rev_id' to 'revision_id' to be consistent with
49
50
# the rest of the code; add a deprecation of the old name.
50
51
 
51
 
from . import (
 
52
from bzrlib import (
52
53
    debug,
53
54
    errors,
54
55
    trace,
 
56
    tree,
55
57
    ui,
56
58
    )
57
 
from .branch import Branch
58
 
from contextlib import ExitStack
59
 
import breezy.config
60
 
from .errors import (BzrError,
61
 
                     ConflictsInTree,
62
 
                     StrictCommitFailed
63
 
                     )
64
 
from .osutils import (get_user_encoding,
65
 
                      has_symlinks,
66
 
                      is_inside_any,
67
 
                      minimum_path_selection,
68
 
                      )
69
 
from .trace import mutter, note, is_quiet
70
 
from .tree import TreeChange
71
 
from .urlutils import unescape_for_display
72
 
from .i18n import gettext
73
 
 
74
 
 
75
 
class PointlessCommit(BzrError):
76
 
 
77
 
    _fmt = "No changes to commit"
78
 
 
79
 
 
80
 
class CannotCommitSelectedFileMerge(BzrError):
81
 
 
82
 
    _fmt = 'Selected-file commit of merges is not supported yet:'\
83
 
        ' files %(files_str)s'
84
 
 
85
 
    def __init__(self, files):
86
 
        files_str = ', '.join(files)
87
 
        BzrError.__init__(self, files=files, files_str=files_str)
88
 
 
89
 
 
90
 
def filter_excluded(iter_changes, exclude):
91
 
    """Filter exclude filenames.
92
 
 
93
 
    :param iter_changes: iter_changes function
94
 
    :param exclude: List of paths to exclude
95
 
    :return: iter_changes function
96
 
    """
97
 
    for change in iter_changes:
98
 
        new_excluded = (change.path[1] is not None and
99
 
                        is_inside_any(exclude, change.path[1]))
100
 
 
101
 
        old_excluded = (change.path[0] is not None and
102
 
                        is_inside_any(exclude, change.path[0]))
103
 
 
104
 
        if old_excluded and new_excluded:
105
 
            continue
106
 
 
107
 
        if old_excluded or new_excluded:
108
 
            # TODO(jelmer): Perhaps raise an error here instead?
109
 
            continue
110
 
 
111
 
        yield change
112
 
 
 
59
from bzrlib.branch import Branch
 
60
from bzrlib.cleanup import OperationWithCleanups
 
61
import bzrlib.config
 
62
from bzrlib.errors import (BzrError, PointlessCommit,
 
63
                           ConflictsInTree,
 
64
                           StrictCommitFailed
 
65
                           )
 
66
from bzrlib.osutils import (get_user_encoding,
 
67
                            is_inside_any,
 
68
                            minimum_path_selection,
 
69
                            splitpath,
 
70
                            )
 
71
from bzrlib.trace import mutter, note, is_quiet
 
72
from bzrlib.inventory import Inventory, InventoryEntry, make_entry
 
73
from bzrlib import symbol_versioning
 
74
from bzrlib.urlutils import unescape_for_display
 
75
from bzrlib.i18n import gettext
113
76
 
114
77
class NullCommitReporter(object):
115
78
    """I report on progress of a commit."""
116
79
 
117
 
    def started(self, revno, revid, location):
 
80
    def started(self, revno, revid, location=None):
 
81
        if location is None:
 
82
            symbol_versioning.warn("As of bzr 1.0 you must pass a location "
 
83
                                   "to started.", DeprecationWarning,
 
84
                                   stacklevel=2)
118
85
        pass
119
86
 
120
87
    def snapshot_change(self, change, path):
150
117
            return
151
118
        self._note("%s %s", change, path)
152
119
 
153
 
    def started(self, revno, rev_id, location):
154
 
        self._note(
155
 
            gettext('Committing to: %s'),
156
 
            unescape_for_display(location, 'utf-8'))
 
120
    def started(self, revno, rev_id, location=None):
 
121
        if location is not None:
 
122
            location = ' to: ' + unescape_for_display(location, 'utf-8')
 
123
        else:
 
124
            # When started was added, location was only made optional by
 
125
            # accident.  Matt Nordhoff 20071129
 
126
            symbol_versioning.warn("As of bzr 1.0 you must pass a location "
 
127
                                   "to started.", DeprecationWarning,
 
128
                                   stacklevel=2)
 
129
            location = ''
 
130
        self._note(gettext('Committing%s'), location)
157
131
 
158
132
    def completed(self, revno, rev_id):
159
 
        if revno is not None:
160
 
            self._note(gettext('Committed revision %d.'), revno)
161
 
            # self._note goes to the console too; so while we want to log the
162
 
            # rev_id, we can't trivially only log it. (See bug 526425). Long
163
 
            # term we should rearrange the reporting structure, but for now
164
 
            # we just mutter seperately. We mutter the revid and revno together
165
 
            # so that concurrent bzr invocations won't lead to confusion.
166
 
            mutter('Committed revid %s as revno %d.', rev_id, revno)
167
 
        else:
168
 
            self._note(gettext('Committed revid %s.'), rev_id)
 
133
        self._note(gettext('Committed revision %d.'), revno)
 
134
        # self._note goes to the console too; so while we want to log the
 
135
        # rev_id, we can't trivially only log it. (See bug 526425). Long
 
136
        # term we should rearrange the reporting structure, but for now
 
137
        # we just mutter seperately. We mutter the revid and revno together
 
138
        # so that concurrent bzr invocations won't lead to confusion.
 
139
        mutter('Committed revid %s as revno %d.', rev_id, revno)
169
140
 
170
141
    def deleted(self, path):
171
142
        self._note(gettext('deleted %s'), path)
192
163
            the working directory; these should be removed from the
193
164
            working inventory.
194
165
    """
195
 
 
196
166
    def __init__(self,
197
167
                 reporter=None,
198
 
                 config_stack=None):
 
168
                 config=None):
199
169
        """Create a Commit object.
200
170
 
201
171
        :param reporter: the default reporter to use or None to decide later
202
172
        """
203
173
        self.reporter = reporter
204
 
        self.config_stack = config_stack
 
174
        self.config = config
205
175
 
206
176
    @staticmethod
207
 
    def update_revprops(revprops, branch, authors=None,
 
177
    def update_revprops(revprops, branch, authors=None, author=None,
208
178
                        local=False, possible_master_transports=None):
209
179
        if revprops is None:
210
180
            revprops = {}
211
181
        if possible_master_transports is None:
212
182
            possible_master_transports = []
213
 
        if (u'branch-nick' not in revprops and
214
 
                branch.repository._format.supports_storing_branch_nick):
215
 
            revprops[u'branch-nick'] = branch._get_nick(
 
183
        if not 'branch-nick' in revprops:
 
184
            revprops['branch-nick'] = branch._get_nick(
216
185
                local,
217
186
                possible_master_transports)
218
187
        if authors is not None:
219
 
            if u'author' in revprops or u'authors' in revprops:
 
188
            if author is not None:
 
189
                raise AssertionError('Specifying both author and authors '
 
190
                        'is not allowed. Specify just authors instead')
 
191
            if 'author' in revprops or 'authors' in revprops:
220
192
                # XXX: maybe we should just accept one of them?
221
193
                raise AssertionError('author property given twice')
222
194
            if authors:
223
195
                for individual in authors:
224
196
                    if '\n' in individual:
225
197
                        raise AssertionError('\\n is not a valid character '
226
 
                                             'in an author identity')
227
 
                revprops[u'authors'] = '\n'.join(authors)
 
198
                                'in an author identity')
 
199
                revprops['authors'] = '\n'.join(authors)
 
200
        if author is not None:
 
201
            symbol_versioning.warn('The parameter author was deprecated'
 
202
                   ' in version 1.13. Use authors instead',
 
203
                   DeprecationWarning)
 
204
            if 'author' in revprops or 'authors' in revprops:
 
205
                # XXX: maybe we should just accept one of them?
 
206
                raise AssertionError('author property given twice')
 
207
            if '\n' in author:
 
208
                raise AssertionError('\\n is not a valid character '
 
209
                        'in an author identity')
 
210
            revprops['authors'] = author
228
211
        return revprops
229
212
 
230
213
    def commit(self,
250
233
        """Commit working copy as a new revision.
251
234
 
252
235
        :param message: the commit message (it or message_callback is required)
253
 
        :param message_callback: A callback: message =
254
 
            message_callback(cmt_obj)
 
236
        :param message_callback: A callback: message = message_callback(cmt_obj)
255
237
 
256
238
        :param timestamp: if not None, seconds-since-epoch for a
257
239
            postdated/predated commit.
283
265
        :param lossy: When committing to a foreign VCS, ignore any
284
266
            data that can not be natively represented.
285
267
        """
286
 
        with ExitStack() as stack:
287
 
            self.revprops = revprops or {}
288
 
            # XXX: Can be set on __init__ or passed in - this is a bit ugly.
289
 
            self.config_stack = config or self.config_stack
290
 
            mutter('preparing to commit')
291
 
 
292
 
            if working_tree is None:
293
 
                raise BzrError("working_tree must be passed into commit().")
294
 
            else:
295
 
                self.work_tree = working_tree
296
 
                self.branch = self.work_tree.branch
297
 
                if getattr(self.work_tree, 'requires_rich_root', lambda: False)():
298
 
                    if not self.branch.repository.supports_rich_root():
299
 
                        raise errors.RootNotRich()
300
 
            if message_callback is None:
301
 
                if message is not None:
302
 
                    if isinstance(message, bytes):
303
 
                        message = message.decode(get_user_encoding())
304
 
 
305
 
                    def message_callback(x):
306
 
                        return message
307
 
                else:
308
 
                    raise BzrError("The message or message_callback keyword"
309
 
                                   " parameter is required for commit().")
310
 
 
311
 
            self.bound_branch = None
312
 
            self.any_entries_deleted = False
313
 
            if exclude is not None:
314
 
                self.exclude = sorted(
315
 
                    minimum_path_selection(exclude))
316
 
            else:
317
 
                self.exclude = []
318
 
            self.local = local
319
 
            self.master_branch = None
320
 
            self.recursive = recursive
321
 
            self.rev_id = None
322
 
            # self.specific_files is None to indicate no filter, or any iterable to
323
 
            # indicate a filter - [] means no files at all, as per iter_changes.
324
 
            if specific_files is not None:
325
 
                self.specific_files = sorted(
326
 
                    minimum_path_selection(specific_files))
327
 
            else:
328
 
                self.specific_files = None
329
 
 
330
 
            self.allow_pointless = allow_pointless
331
 
            self.message_callback = message_callback
332
 
            self.timestamp = timestamp
333
 
            self.timezone = timezone
334
 
            self.committer = committer
335
 
            self.strict = strict
336
 
            self.verbose = verbose
337
 
 
338
 
            stack.enter_context(self.work_tree.lock_write())
339
 
            self.parents = self.work_tree.get_parent_ids()
340
 
            self.pb = ui.ui_factory.nested_progress_bar()
341
 
            stack.callback(self.pb.finished)
342
 
            self.basis_revid = self.work_tree.last_revision()
343
 
            self.basis_tree = self.work_tree.basis_tree()
344
 
            stack.enter_context(self.basis_tree.lock_read())
345
 
            # Cannot commit with conflicts present.
346
 
            if len(self.work_tree.conflicts()) > 0:
347
 
                raise ConflictsInTree
348
 
 
349
 
            # Setup the bound branch variables as needed.
350
 
            self._check_bound_branch(stack, possible_master_transports)
351
 
            if self.config_stack is None:
352
 
                self.config_stack = self.work_tree.get_config_stack()
353
 
 
354
 
            # Check that the working tree is up to date
355
 
            old_revno, old_revid, new_revno = self._check_out_of_date_tree()
356
 
 
357
 
            # Complete configuration setup
358
 
            if reporter is not None:
359
 
                self.reporter = reporter
360
 
            elif self.reporter is None:
361
 
                self.reporter = self._select_reporter()
362
 
 
363
 
            # Setup the progress bar. As the number of files that need to be
364
 
            # committed in unknown, progress is reported as stages.
365
 
            # We keep track of entries separately though and include that
366
 
            # information in the progress bar during the relevant stages.
367
 
            self.pb_stage_name = ""
368
 
            self.pb_stage_count = 0
369
 
            self.pb_stage_total = 5
 
268
        operation = OperationWithCleanups(self._commit)
 
269
        self.revprops = revprops or {}
 
270
        # XXX: Can be set on __init__ or passed in - this is a bit ugly.
 
271
        self.config = config or self.config
 
272
        return operation.run(
 
273
               message=message,
 
274
               timestamp=timestamp,
 
275
               timezone=timezone,
 
276
               committer=committer,
 
277
               specific_files=specific_files,
 
278
               rev_id=rev_id,
 
279
               allow_pointless=allow_pointless,
 
280
               strict=strict,
 
281
               verbose=verbose,
 
282
               working_tree=working_tree,
 
283
               local=local,
 
284
               reporter=reporter,
 
285
               message_callback=message_callback,
 
286
               recursive=recursive,
 
287
               exclude=exclude,
 
288
               possible_master_transports=possible_master_transports,
 
289
               lossy=lossy)
 
290
 
 
291
    def _commit(self, operation, message, timestamp, timezone, committer,
 
292
            specific_files, rev_id, allow_pointless, strict, verbose,
 
293
            working_tree, local, reporter, message_callback, recursive,
 
294
            exclude, possible_master_transports, lossy):
 
295
        mutter('preparing to commit')
 
296
 
 
297
        if working_tree is None:
 
298
            raise BzrError("working_tree must be passed into commit().")
 
299
        else:
 
300
            self.work_tree = working_tree
 
301
            self.branch = self.work_tree.branch
 
302
            if getattr(self.work_tree, 'requires_rich_root', lambda: False)():
 
303
                if not self.branch.repository.supports_rich_root():
 
304
                    raise errors.RootNotRich()
 
305
        if message_callback is None:
 
306
            if message is not None:
 
307
                if isinstance(message, str):
 
308
                    message = message.decode(get_user_encoding())
 
309
                message_callback = lambda x: message
 
310
            else:
 
311
                raise BzrError("The message or message_callback keyword"
 
312
                               " parameter is required for commit().")
 
313
 
 
314
        self.bound_branch = None
 
315
        self.any_entries_deleted = False
 
316
        if exclude is not None:
 
317
            self.exclude = sorted(
 
318
                minimum_path_selection(exclude))
 
319
        else:
 
320
            self.exclude = []
 
321
        self.local = local
 
322
        self.master_branch = None
 
323
        self.recursive = recursive
 
324
        self.rev_id = None
 
325
        # self.specific_files is None to indicate no filter, or any iterable to
 
326
        # indicate a filter - [] means no files at all, as per iter_changes.
 
327
        if specific_files is not None:
 
328
            self.specific_files = sorted(
 
329
                minimum_path_selection(specific_files))
 
330
        else:
 
331
            self.specific_files = None
 
332
 
 
333
        self.allow_pointless = allow_pointless
 
334
        self.message_callback = message_callback
 
335
        self.timestamp = timestamp
 
336
        self.timezone = timezone
 
337
        self.committer = committer
 
338
        self.strict = strict
 
339
        self.verbose = verbose
 
340
 
 
341
        self.work_tree.lock_write()
 
342
        operation.add_cleanup(self.work_tree.unlock)
 
343
        self.parents = self.work_tree.get_parent_ids()
 
344
        # We can use record_iter_changes IFF iter_changes is compatible with
 
345
        # the command line parameters, and the repository has fast delta
 
346
        # generation. See bug 347649.
 
347
        self.use_record_iter_changes = (
 
348
            not self.exclude and 
 
349
            not self.branch.repository._format.supports_tree_reference and
 
350
            (self.branch.repository._format.fast_deltas or
 
351
             len(self.parents) < 2))
 
352
        self.pb = ui.ui_factory.nested_progress_bar()
 
353
        operation.add_cleanup(self.pb.finished)
 
354
        self.basis_revid = self.work_tree.last_revision()
 
355
        self.basis_tree = self.work_tree.basis_tree()
 
356
        self.basis_tree.lock_read()
 
357
        operation.add_cleanup(self.basis_tree.unlock)
 
358
        # Cannot commit with conflicts present.
 
359
        if len(self.work_tree.conflicts()) > 0:
 
360
            raise ConflictsInTree
 
361
 
 
362
        # Setup the bound branch variables as needed.
 
363
        self._check_bound_branch(operation, possible_master_transports)
 
364
 
 
365
        # Check that the working tree is up to date
 
366
        old_revno, old_revid, new_revno = self._check_out_of_date_tree()
 
367
 
 
368
        # Complete configuration setup
 
369
        if reporter is not None:
 
370
            self.reporter = reporter
 
371
        elif self.reporter is None:
 
372
            self.reporter = self._select_reporter()
 
373
        if self.config is None:
 
374
            self.config = self.branch.get_config()
 
375
 
 
376
        self._set_specific_file_ids()
 
377
 
 
378
        # Setup the progress bar. As the number of files that need to be
 
379
        # committed in unknown, progress is reported as stages.
 
380
        # We keep track of entries separately though and include that
 
381
        # information in the progress bar during the relevant stages.
 
382
        self.pb_stage_name = ""
 
383
        self.pb_stage_count = 0
 
384
        self.pb_stage_total = 5
 
385
        if self.bound_branch:
 
386
            # 2 extra stages: "Uploading data to master branch" and "Merging
 
387
            # tags to master branch"
 
388
            self.pb_stage_total += 2
 
389
        self.pb.show_pct = False
 
390
        self.pb.show_spinner = False
 
391
        self.pb.show_eta = False
 
392
        self.pb.show_count = True
 
393
        self.pb.show_bar = True
 
394
 
 
395
        self._gather_parents()
 
396
        # After a merge, a selected file commit is not supported.
 
397
        # See 'bzr help merge' for an explanation as to why.
 
398
        if len(self.parents) > 1 and self.specific_files is not None:
 
399
            raise errors.CannotCommitSelectedFileMerge(self.specific_files)
 
400
        # Excludes are a form of selected file commit.
 
401
        if len(self.parents) > 1 and self.exclude:
 
402
            raise errors.CannotCommitSelectedFileMerge(self.exclude)
 
403
 
 
404
        # Collect the changes
 
405
        self._set_progress_stage("Collecting changes", counter=True)
 
406
        self._lossy = lossy
 
407
        self.builder = self.branch.get_commit_builder(self.parents,
 
408
            self.config, timestamp, timezone, committer, self.revprops,
 
409
            rev_id, lossy=lossy)
 
410
        if not self.builder.supports_record_entry_contents and self.exclude:
 
411
            self.builder.abort()
 
412
            raise errors.ExcludesUnsupported(self.branch.repository)
 
413
 
 
414
        if self.builder.updates_branch and self.bound_branch:
 
415
            self.builder.abort()
 
416
            raise AssertionError(
 
417
                "bound branches not supported for commit builders "
 
418
                "that update the branch")
 
419
 
 
420
        try:
 
421
            self.builder.will_record_deletes()
 
422
            # find the location being committed to
370
423
            if self.bound_branch:
371
 
                # 2 extra stages: "Uploading data to master branch" and "Merging
372
 
                # tags to master branch"
373
 
                self.pb_stage_total += 2
374
 
            self.pb.show_pct = False
375
 
            self.pb.show_spinner = False
376
 
            self.pb.show_eta = False
377
 
            self.pb.show_count = True
378
 
            self.pb.show_bar = True
379
 
 
380
 
            # After a merge, a selected file commit is not supported.
381
 
            # See 'bzr help merge' for an explanation as to why.
382
 
            if len(self.parents) > 1 and self.specific_files is not None:
383
 
                raise CannotCommitSelectedFileMerge(self.specific_files)
384
 
            # Excludes are a form of selected file commit.
385
 
            if len(self.parents) > 1 and self.exclude:
386
 
                raise CannotCommitSelectedFileMerge(self.exclude)
387
 
 
388
 
            # Collect the changes
389
 
            self._set_progress_stage("Collecting changes", counter=True)
390
 
            self._lossy = lossy
391
 
            self.builder = self.branch.get_commit_builder(
392
 
                self.parents, self.config_stack, timestamp, timezone, committer,
393
 
                self.revprops, rev_id, lossy=lossy)
394
 
 
395
 
            if self.builder.updates_branch and self.bound_branch:
396
 
                self.builder.abort()
397
 
                raise AssertionError(
398
 
                    "bound branches not supported for commit builders "
399
 
                    "that update the branch")
400
 
 
401
 
            try:
402
 
                # find the location being committed to
403
 
                if self.bound_branch:
404
 
                    master_location = self.master_branch.base
405
 
                else:
406
 
                    master_location = self.branch.base
407
 
 
408
 
                # report the start of the commit
409
 
                self.reporter.started(new_revno, self.rev_id, master_location)
410
 
 
411
 
                self._update_builder_with_changes()
412
 
                self._check_pointless()
413
 
 
414
 
                # TODO: Now the new inventory is known, check for conflicts.
415
 
                # ADHB 2006-08-08: If this is done, populate_new_inv should not add
416
 
                # weave lines, because nothing should be recorded until it is known
417
 
                # that commit will succeed.
418
 
                self._set_progress_stage("Saving data locally")
419
 
                self.builder.finish_inventory()
420
 
 
421
 
                # Prompt the user for a commit message if none provided
422
 
                message = message_callback(self)
423
 
                self.message = message
424
 
 
425
 
                # Add revision data to the local branch
426
 
                self.rev_id = self.builder.commit(self.message)
427
 
 
428
 
            except Exception:
429
 
                mutter("aborting commit write group because of exception:")
430
 
                trace.log_exception_quietly()
431
 
                self.builder.abort()
432
 
                raise
433
 
 
434
 
            self._update_branches(old_revno, old_revid, new_revno)
435
 
 
436
 
            # Make the working tree be up to date with the branch. This
437
 
            # includes automatic changes scheduled to be made to the tree, such
438
 
            # as updating its basis and unversioning paths that were missing.
439
 
            self.work_tree.unversion(self.deleted_paths)
440
 
            self._set_progress_stage("Updating the working tree")
441
 
            self.work_tree.update_basis_by_delta(
442
 
                self.rev_id, self.builder.get_basis_delta())
443
 
            self.reporter.completed(new_revno, self.rev_id)
444
 
            self._process_post_hooks(old_revno, new_revno)
445
 
            return self.rev_id
 
424
                master_location = self.master_branch.base
 
425
            else:
 
426
                master_location = self.branch.base
 
427
 
 
428
            # report the start of the commit
 
429
            self.reporter.started(new_revno, self.rev_id, master_location)
 
430
 
 
431
            self._update_builder_with_changes()
 
432
            self._check_pointless()
 
433
 
 
434
            # TODO: Now the new inventory is known, check for conflicts.
 
435
            # ADHB 2006-08-08: If this is done, populate_new_inv should not add
 
436
            # weave lines, because nothing should be recorded until it is known
 
437
            # that commit will succeed.
 
438
            self._set_progress_stage("Saving data locally")
 
439
            self.builder.finish_inventory()
 
440
 
 
441
            # Prompt the user for a commit message if none provided
 
442
            message = message_callback(self)
 
443
            self.message = message
 
444
 
 
445
            # Add revision data to the local branch
 
446
            self.rev_id = self.builder.commit(self.message)
 
447
 
 
448
        except Exception, e:
 
449
            mutter("aborting commit write group because of exception:")
 
450
            trace.log_exception_quietly()
 
451
            self.builder.abort()
 
452
            raise
 
453
 
 
454
        self._update_branches(old_revno, old_revid, new_revno)
 
455
 
 
456
        # Make the working tree be up to date with the branch. This
 
457
        # includes automatic changes scheduled to be made to the tree, such
 
458
        # as updating its basis and unversioning paths that were missing.
 
459
        self.work_tree.unversion(self.deleted_ids)
 
460
        self._set_progress_stage("Updating the working tree")
 
461
        self.work_tree.update_basis_by_delta(self.rev_id,
 
462
             self.builder.get_basis_delta())
 
463
        self.reporter.completed(new_revno, self.rev_id)
 
464
        self._process_post_hooks(old_revno, new_revno)
 
465
        return self.rev_id
446
466
 
447
467
    def _update_branches(self, old_revno, old_revid, new_revno):
448
468
        """Update the master and local branch to the new revision.
470
490
                    self.branch.fetch(self.master_branch, self.rev_id)
471
491
 
472
492
            # and now do the commit locally.
473
 
            if new_revno is None:
474
 
                # Keep existing behaviour around ghosts
475
 
                new_revno = 1
476
493
            self.branch.set_last_revision_info(new_revno, self.rev_id)
477
494
        else:
478
495
            try:
479
496
                self._process_pre_hooks(old_revno, new_revno)
480
 
            except BaseException:
 
497
            except:
481
498
                # The commit builder will already have updated the branch,
482
499
                # revert it.
483
500
                self.branch.set_last_revision_info(old_revno, old_revid)
490
507
                self.master_branch.tags)
491
508
            if tag_conflicts:
492
509
                warning_lines = ['    ' + name for name, _, _ in tag_conflicts]
493
 
                note(gettext("Conflicting tags in bound branch:\n{0}".format(
494
 
                    "\n".join(warning_lines))))
 
510
                note( gettext("Conflicting tags in bound branch:\n{0}".format(
 
511
                    "\n".join(warning_lines))) )
495
512
 
496
513
    def _select_reporter(self):
497
514
        """Select the CommitReporter to use."""
509
526
            return
510
527
        raise PointlessCommit()
511
528
 
512
 
    def _check_bound_branch(self, stack, possible_master_transports=None):
 
529
    def _check_bound_branch(self, operation, possible_master_transports=None):
513
530
        """Check to see if the local branch is bound.
514
531
 
515
532
        If it is bound, then most of the commit will actually be
531
548
        # If the master branch is bound, we must fail
532
549
        master_bound_location = self.master_branch.get_bound_location()
533
550
        if master_bound_location:
534
 
            raise errors.CommitToDoubleBoundBranch(
535
 
                self.branch, self.master_branch, master_bound_location)
 
551
            raise errors.CommitToDoubleBoundBranch(self.branch,
 
552
                    self.master_branch, master_bound_location)
536
553
 
537
554
        # TODO: jam 20051230 We could automatically push local
538
555
        #       commits to the remote branch if they would fit.
540
557
        #       to local.
541
558
 
542
559
        # Make sure the local branch is identical to the master
543
 
        master_revid = self.master_branch.last_revision()
544
 
        local_revid = self.branch.last_revision()
545
 
        if local_revid != master_revid:
 
560
        master_info = self.master_branch.last_revision_info()
 
561
        local_info = self.branch.last_revision_info()
 
562
        if local_info != master_info:
546
563
            raise errors.BoundBranchOutOfDate(self.branch,
547
 
                                              self.master_branch)
 
564
                    self.master_branch)
548
565
 
549
566
        # Now things are ready to change the master branch
550
567
        # so grab the lock
551
568
        self.bound_branch = self.branch
552
 
        stack.enter_context(self.master_branch.lock_write())
 
569
        self.master_branch.lock_write()
 
570
        operation.add_cleanup(self.master_branch.unlock)
553
571
 
554
572
    def _check_out_of_date_tree(self):
555
573
        """Check that the working tree is up to date.
564
582
            # this is so that we still consider the master branch
565
583
            # - in a checkout scenario the tree may have no
566
584
            # parents but the branch may do.
567
 
            first_tree_parent = breezy.revision.NULL_REVISION
568
 
        if (self.master_branch._format.stores_revno() or
569
 
                self.config_stack.get('calculate_revnos')):
570
 
            try:
571
 
                old_revno, master_last = self.master_branch.last_revision_info()
572
 
            except errors.UnsupportedOperation:
573
 
                master_last = self.master_branch.last_revision()
574
 
                old_revno = self.branch.revision_id_to_revno(master_last)
575
 
        else:
576
 
            master_last = self.master_branch.last_revision()
577
 
            old_revno = None
 
585
            first_tree_parent = bzrlib.revision.NULL_REVISION
 
586
        old_revno, master_last = self.master_branch.last_revision_info()
578
587
        if master_last != first_tree_parent:
579
 
            if master_last != breezy.revision.NULL_REVISION:
 
588
            if master_last != bzrlib.revision.NULL_REVISION:
580
589
                raise errors.OutOfDateTree(self.work_tree)
581
 
        if (old_revno is not None and
582
 
                self.branch.repository.has_revision(first_tree_parent)):
 
590
        if self.branch.repository.has_revision(first_tree_parent):
583
591
            new_revno = old_revno + 1
584
592
        else:
585
593
            # ghost parents never appear in revision history.
586
 
            new_revno = None
 
594
            new_revno = 1
587
595
        return old_revno, master_last, new_revno
588
596
 
589
597
    def _process_pre_hooks(self, old_revno, new_revno):
596
604
        # Process the post commit hooks, if any
597
605
        self._set_progress_stage("Running post_commit hooks")
598
606
        # old style commit hooks - should be deprecated ? (obsoleted in
599
 
        # 0.15^H^H^H^H 2.5.0)
600
 
        post_commit = self.config_stack.get('post_commit')
601
 
        if post_commit is not None:
602
 
            hooks = post_commit.split(' ')
 
607
        # 0.15)
 
608
        if self.config.post_commit() is not None:
 
609
            hooks = self.config.post_commit().split(' ')
603
610
            # this would be nicer with twisted.python.reflect.namedAny
604
611
            for hook in hooks:
605
612
                result = eval(hook + '(branch, rev_id)',
606
 
                              {'branch': self.branch,
607
 
                               'breezy': breezy,
608
 
                               'rev_id': self.rev_id})
 
613
                              {'branch':self.branch,
 
614
                               'bzrlib':bzrlib,
 
615
                               'rev_id':self.rev_id})
609
616
        # process new style post commit hooks
610
617
        self._process_hooks("post_commit", old_revno, new_revno)
611
618
 
626
633
        if self.parents:
627
634
            old_revid = self.parents[0]
628
635
        else:
629
 
            old_revid = breezy.revision.NULL_REVISION
 
636
            old_revid = bzrlib.revision.NULL_REVISION
630
637
 
631
638
        if hook_name == "pre_commit":
632
639
            future_tree = self.builder.revision_tree()
633
640
            tree_delta = future_tree.changes_from(self.basis_tree,
634
 
                                                  include_root=True)
 
641
                                             include_root=True)
635
642
 
636
643
        for hook in Branch.hooks[hook_name]:
637
644
            # show the running hook in the progress bar. As hooks may
652
659
                     old_revno, old_revid, new_revno, self.rev_id,
653
660
                     tree_delta, future_tree)
654
661
 
 
662
    def _gather_parents(self):
 
663
        """Record the parents of a merge for merge detection."""
 
664
        # TODO: Make sure that this list doesn't contain duplicate
 
665
        # entries and the order is preserved when doing this.
 
666
        if self.use_record_iter_changes:
 
667
            return
 
668
        self.basis_inv = self.basis_tree.inventory
 
669
        self.parent_invs = [self.basis_inv]
 
670
        for revision in self.parents[1:]:
 
671
            if self.branch.repository.has_revision(revision):
 
672
                mutter('commit parent revision {%s}', revision)
 
673
                inventory = self.branch.repository.get_inventory(revision)
 
674
                self.parent_invs.append(inventory)
 
675
            else:
 
676
                mutter('commit parent ghost revision {%s}', revision)
 
677
 
655
678
    def _update_builder_with_changes(self):
656
679
        """Update the commit builder with the data about what has changed.
657
680
        """
 
681
        exclude = self.exclude
658
682
        specific_files = self.specific_files
659
 
        mutter("Selecting files for commit with filter %r", specific_files)
 
683
        mutter("Selecting files for commit with filter %s", specific_files)
660
684
 
661
685
        self._check_strict()
662
 
        iter_changes = self.work_tree.iter_changes(
663
 
            self.basis_tree, specific_files=specific_files)
664
 
        if self.exclude:
665
 
            iter_changes = filter_excluded(iter_changes, self.exclude)
666
 
        iter_changes = self._filter_iter_changes(iter_changes)
667
 
        for path, fs_hash in self.builder.record_iter_changes(
 
686
        if self.use_record_iter_changes:
 
687
            iter_changes = self.work_tree.iter_changes(self.basis_tree,
 
688
                specific_files=specific_files)
 
689
            iter_changes = self._filter_iter_changes(iter_changes)
 
690
            for file_id, path, fs_hash in self.builder.record_iter_changes(
668
691
                self.work_tree, self.basis_revid, iter_changes):
669
 
            self.work_tree._observed_sha1(path, fs_hash)
 
692
                self.work_tree._observed_sha1(file_id, path, fs_hash)
 
693
        else:
 
694
            # Build the new inventory
 
695
            self._populate_from_inventory()
 
696
            self._record_unselected()
 
697
            self._report_and_accumulate_deletes()
670
698
 
671
699
    def _filter_iter_changes(self, iter_changes):
672
700
        """Process iter_changes.
673
701
 
674
 
        This method reports on the changes in iter_changes to the user, and
 
702
        This method reports on the changes in iter_changes to the user, and 
675
703
        converts 'missing' entries in the iter_changes iterator to 'deleted'
676
704
        entries. 'missing' entries have their
677
705
 
680
708
        """
681
709
        reporter = self.reporter
682
710
        report_changes = reporter.is_verbose()
683
 
        deleted_paths = []
 
711
        deleted_ids = []
684
712
        for change in iter_changes:
685
713
            if report_changes:
686
 
                old_path = change.path[0]
687
 
                new_path = change.path[1]
688
 
                versioned = change.versioned[1]
689
 
            kind = change.kind[1]
690
 
            versioned = change.versioned[1]
 
714
                old_path = change[1][0]
 
715
                new_path = change[1][1]
 
716
                versioned = change[3][1]
 
717
            kind = change[6][1]
 
718
            versioned = change[3][1]
691
719
            if kind is None and versioned:
692
720
                # 'missing' path
693
721
                if report_changes:
694
722
                    reporter.missing(new_path)
695
 
                if change.kind[0] == 'symlink' and not self.work_tree.supports_symlinks():
696
 
                    trace.warning('Ignoring "%s" as symlinks are not '
697
 
                                  'supported on this filesystem.' % (change.path[0],))
698
 
                    continue
699
 
                deleted_paths.append(change.path[1])
 
723
                deleted_ids.append(change[0])
700
724
                # Reset the new path (None) and new versioned flag (False)
701
 
                change = change.discard_new()
702
 
                new_path = change.path[1]
 
725
                change = (change[0], (change[1][0], None), change[2],
 
726
                    (change[3][0], False)) + change[4:]
 
727
                new_path = change[1][1]
703
728
                versioned = False
704
729
            elif kind == 'tree-reference':
705
730
                if self.recursive == 'down':
706
 
                    self._commit_nested_tree(change.path[1])
707
 
            if change.versioned[0] or change.versioned[1]:
 
731
                    self._commit_nested_tree(change[0], change[1][1])
 
732
            if change[3][0] or change[3][1]:
708
733
                yield change
709
734
                if report_changes:
710
735
                    if new_path is None:
712
737
                    elif old_path is None:
713
738
                        reporter.snapshot_change(gettext('added'), new_path)
714
739
                    elif old_path != new_path:
715
 
                        reporter.renamed(gettext('renamed'),
716
 
                                         old_path, new_path)
 
740
                        reporter.renamed(gettext('renamed'), old_path, new_path)
717
741
                    else:
718
 
                        if (new_path
719
 
                                or self.work_tree.branch.repository._format.rich_root_data):
 
742
                        if (new_path or 
 
743
                            self.work_tree.branch.repository._format.rich_root_data):
720
744
                            # Don't report on changes to '' in non rich root
721
745
                            # repositories.
722
 
                            reporter.snapshot_change(
723
 
                                gettext('modified'), new_path)
 
746
                            reporter.snapshot_change(gettext('modified'), new_path)
724
747
            self._next_progress_entry()
725
 
        # Unversion files that were found to be deleted
726
 
        self.deleted_paths = deleted_paths
 
748
        # Unversion IDs that were found to be deleted
 
749
        self.deleted_ids = deleted_ids
 
750
 
 
751
    def _record_unselected(self):
 
752
        # If specific files are selected, then all un-selected files must be
 
753
        # recorded in their previous state. For more details, see
 
754
        # https://lists.ubuntu.com/archives/bazaar/2007q3/028476.html.
 
755
        if self.specific_files or self.exclude:
 
756
            specific_files = self.specific_files or []
 
757
            for path, old_ie in self.basis_inv.iter_entries():
 
758
                if self.builder.new_inventory.has_id(old_ie.file_id):
 
759
                    # already added - skip.
 
760
                    continue
 
761
                if (is_inside_any(specific_files, path)
 
762
                    and not is_inside_any(self.exclude, path)):
 
763
                    # was inside the selected path, and not excluded - if not
 
764
                    # present it has been deleted so skip.
 
765
                    continue
 
766
                # From here down it was either not selected, or was excluded:
 
767
                # We preserve the entry unaltered.
 
768
                ie = old_ie.copy()
 
769
                # Note: specific file commits after a merge are currently
 
770
                # prohibited. This test is for sanity/safety in case it's
 
771
                # required after that changes.
 
772
                if len(self.parents) > 1:
 
773
                    ie.revision = None
 
774
                self.builder.record_entry_contents(ie, self.parent_invs, path,
 
775
                    self.basis_tree, None)
 
776
 
 
777
    def _report_and_accumulate_deletes(self):
 
778
        if (isinstance(self.basis_inv, Inventory)
 
779
            and isinstance(self.builder.new_inventory, Inventory)):
 
780
            # the older Inventory classes provide a _byid dict, and building a
 
781
            # set from the keys of this dict is substantially faster than even
 
782
            # getting a set of ids from the inventory
 
783
            #
 
784
            # <lifeless> set(dict) is roughly the same speed as
 
785
            # set(iter(dict)) and both are significantly slower than
 
786
            # set(dict.keys())
 
787
            deleted_ids = set(self.basis_inv._byid.keys()) - \
 
788
               set(self.builder.new_inventory._byid.keys())
 
789
        else:
 
790
            deleted_ids = set(self.basis_inv) - set(self.builder.new_inventory)
 
791
        if deleted_ids:
 
792
            self.any_entries_deleted = True
 
793
            deleted = [(self.basis_tree.id2path(file_id), file_id)
 
794
                for file_id in deleted_ids]
 
795
            deleted.sort()
 
796
            # XXX: this is not quite directory-order sorting
 
797
            for path, file_id in deleted:
 
798
                self.builder.record_delete(path, file_id)
 
799
                self.reporter.deleted(path)
727
800
 
728
801
    def _check_strict(self):
729
802
        # XXX: when we use iter_changes this would likely be faster if
734
807
            for unknown in self.work_tree.unknowns():
735
808
                raise StrictCommitFailed()
736
809
 
737
 
    def _commit_nested_tree(self, path):
 
810
    def _populate_from_inventory(self):
 
811
        """Populate the CommitBuilder by walking the working tree inventory."""
 
812
        # Build the revision inventory.
 
813
        #
 
814
        # This starts by creating a new empty inventory. Depending on
 
815
        # which files are selected for commit, and what is present in the
 
816
        # current tree, the new inventory is populated. inventory entries
 
817
        # which are candidates for modification have their revision set to
 
818
        # None; inventory entries that are carried over untouched have their
 
819
        # revision set to their prior value.
 
820
        #
 
821
        # ESEPARATIONOFCONCERNS: this function is diffing and using the diff
 
822
        # results to create a new inventory at the same time, which results
 
823
        # in bugs like #46635.  Any reason not to use/enhance Tree.changes_from?
 
824
        # ADHB 11-07-2006
 
825
 
 
826
        specific_files = self.specific_files
 
827
        exclude = self.exclude
 
828
        report_changes = self.reporter.is_verbose()
 
829
        deleted_ids = []
 
830
        # A tree of paths that have been deleted. E.g. if foo/bar has been
 
831
        # deleted, then we have {'foo':{'bar':{}}}
 
832
        deleted_paths = {}
 
833
        # XXX: Note that entries may have the wrong kind because the entry does
 
834
        # not reflect the status on disk.
 
835
        work_inv = self.work_tree.inventory
 
836
        # NB: entries will include entries within the excluded ids/paths
 
837
        # because iter_entries_by_dir has no 'exclude' facility today.
 
838
        entries = work_inv.iter_entries_by_dir(
 
839
            specific_file_ids=self.specific_file_ids, yield_parents=True)
 
840
        for path, existing_ie in entries:
 
841
            file_id = existing_ie.file_id
 
842
            name = existing_ie.name
 
843
            parent_id = existing_ie.parent_id
 
844
            kind = existing_ie.kind
 
845
            # Skip files that have been deleted from the working tree.
 
846
            # The deleted path ids are also recorded so they can be explicitly
 
847
            # unversioned later.
 
848
            if deleted_paths:
 
849
                path_segments = splitpath(path)
 
850
                deleted_dict = deleted_paths
 
851
                for segment in path_segments:
 
852
                    deleted_dict = deleted_dict.get(segment, None)
 
853
                    if not deleted_dict:
 
854
                        # We either took a path not present in the dict
 
855
                        # (deleted_dict was None), or we've reached an empty
 
856
                        # child dir in the dict, so are now a sub-path.
 
857
                        break
 
858
                else:
 
859
                    deleted_dict = None
 
860
                if deleted_dict is not None:
 
861
                    # the path has a deleted parent, do not add it.
 
862
                    continue
 
863
            if exclude and is_inside_any(exclude, path):
 
864
                # Skip excluded paths. Excluded paths are processed by
 
865
                # _update_builder_with_changes.
 
866
                continue
 
867
            content_summary = self.work_tree.path_content_summary(path)
 
868
            kind = content_summary[0]
 
869
            # Note that when a filter of specific files is given, we must only
 
870
            # skip/record deleted files matching that filter.
 
871
            if not specific_files or is_inside_any(specific_files, path):
 
872
                if kind == 'missing':
 
873
                    if not deleted_paths:
 
874
                        # path won't have been split yet.
 
875
                        path_segments = splitpath(path)
 
876
                    deleted_dict = deleted_paths
 
877
                    for segment in path_segments:
 
878
                        deleted_dict = deleted_dict.setdefault(segment, {})
 
879
                    self.reporter.missing(path)
 
880
                    self._next_progress_entry()
 
881
                    deleted_ids.append(file_id)
 
882
                    continue
 
883
            # TODO: have the builder do the nested commit just-in-time IF and
 
884
            # only if needed.
 
885
            if kind == 'tree-reference':
 
886
                # enforce repository nested tree policy.
 
887
                if (not self.work_tree.supports_tree_reference() or
 
888
                    # repository does not support it either.
 
889
                    not self.branch.repository._format.supports_tree_reference):
 
890
                    kind = 'directory'
 
891
                    content_summary = (kind, None, None, None)
 
892
                elif self.recursive == 'down':
 
893
                    nested_revision_id = self._commit_nested_tree(
 
894
                        file_id, path)
 
895
                    content_summary = (kind, None, None, nested_revision_id)
 
896
                else:
 
897
                    nested_revision_id = self.work_tree.get_reference_revision(file_id)
 
898
                    content_summary = (kind, None, None, nested_revision_id)
 
899
 
 
900
            # Record an entry for this item
 
901
            # Note: I don't particularly want to have the existing_ie
 
902
            # parameter but the test suite currently (28-Jun-07) breaks
 
903
            # without it thanks to a unicode normalisation issue. :-(
 
904
            definitely_changed = kind != existing_ie.kind
 
905
            self._record_entry(path, file_id, specific_files, kind, name,
 
906
                parent_id, definitely_changed, existing_ie, report_changes,
 
907
                content_summary)
 
908
 
 
909
        # Unversion IDs that were found to be deleted
 
910
        self.deleted_ids = deleted_ids
 
911
 
 
912
    def _commit_nested_tree(self, file_id, path):
738
913
        "Commit a nested tree."
739
 
        sub_tree = self.work_tree.get_nested_tree(path)
 
914
        sub_tree = self.work_tree.get_nested_tree(file_id, path)
740
915
        # FIXME: be more comprehensive here:
741
916
        # this works when both trees are in --trees repository,
742
917
        # but when both are bound to a different repository,
744
919
        # finally implement the explicit-caches approach design
745
920
        # a while back - RBC 20070306.
746
921
        if sub_tree.branch.repository.has_same_location(
747
 
                self.work_tree.branch.repository):
 
922
            self.work_tree.branch.repository):
748
923
            sub_tree.branch.repository = \
749
924
                self.work_tree.branch.repository
750
925
        try:
751
926
            return sub_tree.commit(message=None, revprops=self.revprops,
752
 
                                   recursive=self.recursive,
753
 
                                   message_callback=self.message_callback,
754
 
                                   timestamp=self.timestamp,
755
 
                                   timezone=self.timezone,
756
 
                                   committer=self.committer,
757
 
                                   allow_pointless=self.allow_pointless,
758
 
                                   strict=self.strict, verbose=self.verbose,
759
 
                                   local=self.local, reporter=self.reporter)
760
 
        except PointlessCommit:
761
 
            return self.work_tree.get_reference_revision(path)
 
927
                recursive=self.recursive,
 
928
                message_callback=self.message_callback,
 
929
                timestamp=self.timestamp, timezone=self.timezone,
 
930
                committer=self.committer,
 
931
                allow_pointless=self.allow_pointless,
 
932
                strict=self.strict, verbose=self.verbose,
 
933
                local=self.local, reporter=self.reporter)
 
934
        except errors.PointlessCommit:
 
935
            return self.work_tree.get_reference_revision(file_id)
 
936
 
 
937
    def _record_entry(self, path, file_id, specific_files, kind, name,
 
938
        parent_id, definitely_changed, existing_ie, report_changes,
 
939
        content_summary):
 
940
        "Record the new inventory entry for a path if any."
 
941
        # mutter('check %s {%s}', path, file_id)
 
942
        # mutter('%s selected for commit', path)
 
943
        if definitely_changed or existing_ie is None:
 
944
            ie = make_entry(kind, name, parent_id, file_id)
 
945
        else:
 
946
            ie = existing_ie.copy()
 
947
            ie.revision = None
 
948
        # For carried over entries we don't care about the fs hash - the repo
 
949
        # isn't generating a sha, so we're not saving computation time.
 
950
        _, _, fs_hash = self.builder.record_entry_contents(
 
951
            ie, self.parent_invs, path, self.work_tree, content_summary)
 
952
        if report_changes:
 
953
            self._report_change(ie, path)
 
954
        if fs_hash:
 
955
            self.work_tree._observed_sha1(ie.file_id, path, fs_hash)
 
956
        return ie
 
957
 
 
958
    def _report_change(self, ie, path):
 
959
        """Report a change to the user.
 
960
 
 
961
        The change that has occurred is described relative to the basis
 
962
        inventory.
 
963
        """
 
964
        if (self.basis_inv.has_id(ie.file_id)):
 
965
            basis_ie = self.basis_inv[ie.file_id]
 
966
        else:
 
967
            basis_ie = None
 
968
        change = ie.describe_change(basis_ie, ie)
 
969
        if change in (InventoryEntry.RENAMED,
 
970
            InventoryEntry.MODIFIED_AND_RENAMED):
 
971
            old_path = self.basis_inv.id2path(ie.file_id)
 
972
            self.reporter.renamed(change, old_path, path)
 
973
            self._next_progress_entry()
 
974
        else:
 
975
            if change == gettext('unchanged'):
 
976
                return
 
977
            self.reporter.snapshot_change(change, path)
 
978
            self._next_progress_entry()
762
979
 
763
980
    def _set_progress_stage(self, name, counter=False):
764
981
        """Set the progress stage and emit an update to the progress bar."""
778
995
    def _emit_progress(self):
779
996
        if self.pb_entries_count is not None:
780
997
            text = gettext("{0} [{1}] - Stage").format(self.pb_stage_name,
781
 
                                                       self.pb_entries_count)
 
998
                self.pb_entries_count)
782
999
        else:
783
1000
            text = gettext("%s - Stage") % (self.pb_stage_name, )
784
1001
        self.pb.update(text, self.pb_stage_count, self.pb_stage_total)
 
1002
 
 
1003
    def _set_specific_file_ids(self):
 
1004
        """populate self.specific_file_ids if we will use it."""
 
1005
        if not self.use_record_iter_changes:
 
1006
            # If provided, ensure the specified files are versioned
 
1007
            if self.specific_files is not None:
 
1008
                # Note: This routine is being called because it raises
 
1009
                # PathNotVersionedError as a side effect of finding the IDs. We
 
1010
                # later use the ids we found as input to the working tree
 
1011
                # inventory iterator, so we only consider those ids rather than
 
1012
                # examining the whole tree again.
 
1013
                # XXX: Dont we have filter_unversioned to do this more
 
1014
                # cheaply?
 
1015
                self.specific_file_ids = tree.find_ids_across_trees(
 
1016
                    self.specific_files, [self.basis_tree, self.work_tree])
 
1017
            else:
 
1018
                self.specific_file_ids = None