← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/shelf_ui.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/shelf_ui.py
1
 
# Copyright (C) 2008 Canonical Ltd
 
1
# Copyright (C) 2008, 2009, 2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
27
27
    errors,
28
28
    osutils,
29
29
    patches,
 
30
    patiencediff,
30
31
    shelf,
31
32
    textfile,
32
33
    trace,
35
36
)
36
37
 
37
38
 
 
39
class UseEditor(Exception):
 
40
    """Use an editor instead of selecting hunks."""
 
41
 
 
42
 
38
43
class ShelfReporter(object):
39
44
 
40
45
    vocab = {'add file': 'Shelve adding file "%(path)s"?',
143
148
        if reporter is None:
144
149
            reporter = ShelfReporter()
145
150
        self.reporter = reporter
 
151
        config = self.work_tree.branch.get_config()
 
152
        self.change_editor = config.get_change_editor(target_tree, work_tree)
 
153
        self.work_tree.lock_tree_write()
146
154
 
147
155
    @classmethod
148
156
    def from_args(klass, diff_writer, revision=None, all=False, file_list=None,
149
157
                  message=None, directory='.', destroy=False):
150
158
        """Create a shelver from commandline arguments.
151
159
 
 
160
        The returned shelver wil have a work_tree that is locked and should
 
161
        be unlocked.
 
162
 
152
163
        :param revision: RevisionSpec of the revision to compare to.
153
164
        :param all: If True, shelve all changes without prompting.
154
165
        :param file_list: If supplied, only files in this list may be  shelved.
158
169
            changes.
159
170
        """
160
171
        tree, path = workingtree.WorkingTree.open_containing(directory)
161
 
        target_tree = builtins._get_one_revision_tree('shelf2', revision,
162
 
            tree.branch, tree)
163
 
        files = builtins.safe_relpath_files(tree, file_list)
164
 
        return klass(tree, target_tree, diff_writer, all, all, files, message,
165
 
                     destroy)
 
172
        # Ensure that tree is locked for the lifetime of target_tree, as
 
173
        # target tree may be reading from the same dirstate.
 
174
        tree.lock_tree_write()
 
175
        try:
 
176
            target_tree = builtins._get_one_revision_tree('shelf2', revision,
 
177
                tree.branch, tree)
 
178
            files = tree.safe_relpath_files(file_list)
 
179
            return klass(tree, target_tree, diff_writer, all, all, files,
 
180
                         message, destroy)
 
181
        finally:
 
182
            tree.unlock()
166
183
 
167
184
    def run(self):
168
185
        """Interactively shelve the changes."""
201
218
            shutil.rmtree(self.tempdir)
202
219
            creator.finalize()
203
220
 
 
221
    def finalize(self):
 
222
        if self.change_editor is not None:
 
223
            self.change_editor.finish()
 
224
        self.work_tree.unlock()
 
225
 
 
226
 
204
227
    def get_parsed_patch(self, file_id, invert=False):
205
228
        """Return a parsed version of a file's patch.
206
229
 
218
241
            new_tree = self.work_tree
219
242
        old_path = old_tree.id2path(file_id)
220
243
        new_path = new_tree.id2path(file_id)
221
 
        text_differ = diff.DiffText(old_tree, new_tree, diff_file)
 
244
        text_differ = diff.DiffText(old_tree, new_tree, diff_file,
 
245
            path_encoding=osutils.get_terminal_encoding())
222
246
        patch = text_differ.diff(file_id, old_path, new_path, 'file', 'file')
223
247
        diff_file.seek(0)
224
248
        return patches.parse_patch(diff_file)
229
253
        :param message: The message to prompt a user with.
230
254
        :return: A character.
231
255
        """
 
256
        if not sys.stdin.isatty():
 
257
            # Since there is no controlling terminal we will hang when trying
 
258
            # to prompt the user, better abort now.  See
 
259
            # https://code.launchpad.net/~bialix/bzr/shelve-no-tty/+merge/14905
 
260
            # for more context.
 
261
            raise errors.BzrError("You need a controlling terminal.")
232
262
        sys.stdout.write(message)
233
263
        char = osutils.getchar()
234
264
        sys.stdout.write("\r" + ' ' * len(message) + '\r')
235
265
        sys.stdout.flush()
236
266
        return char
237
267
 
238
 
    def prompt_bool(self, question, long=False):
 
268
    def prompt_bool(self, question, long=False, allow_editor=False):
239
269
        """Prompt the user with a yes/no question.
240
270
 
241
271
        This may be overridden by self.auto.  It may also *set* self.auto.  It
245
275
        """
246
276
        if self.auto:
247
277
            return True
 
278
        editor_string = ''
248
279
        if long:
249
 
            prompt = ' [(y)es, (N)o, (f)inish, or (q)uit]'
 
280
            if allow_editor:
 
281
                editor_string = '(E)dit manually, '
 
282
            prompt = ' [(y)es, (N)o, %s(f)inish, or (q)uit]' % editor_string
250
283
        else:
251
 
            prompt = ' [yNfq?]'
 
284
            if allow_editor:
 
285
                editor_string = 'e'
 
286
            prompt = ' [yN%sfq?]' % editor_string
252
287
        char = self.prompt(question + prompt)
253
288
        if char == 'y':
254
289
            return True
 
290
        elif char == 'e' and allow_editor:
 
291
            raise UseEditor
255
292
        elif char == 'f':
256
293
            self.auto = True
257
294
            return True
263
300
            return False
264
301
 
265
302
    def handle_modify_text(self, creator, file_id):
 
303
        """Handle modified text, by using hunk selection or file editing.
 
304
 
 
305
        :param creator: A ShelfCreator.
 
306
        :param file_id: The id of the file that was modified.
 
307
        :return: The number of changes.
 
308
        """
 
309
        work_tree_lines = self.work_tree.get_file_lines(file_id)
 
310
        try:
 
311
            lines, change_count = self._select_hunks(creator, file_id,
 
312
                                                     work_tree_lines)
 
313
        except UseEditor:
 
314
            lines, change_count = self._edit_file(file_id, work_tree_lines)
 
315
        if change_count != 0:
 
316
            creator.shelve_lines(file_id, lines)
 
317
        return change_count
 
318
 
 
319
    def _select_hunks(self, creator, file_id, work_tree_lines):
266
320
        """Provide diff hunk selection for modified text.
267
321
 
268
322
        If self.reporter.invert_diff is True, the diff is inverted so that
270
324
 
271
325
        :param creator: a ShelfCreator
272
326
        :param file_id: The id of the file to shelve.
 
327
        :param work_tree_lines: Line contents of the file in the working tree.
273
328
        :return: number of shelved hunks.
274
329
        """
275
330
        if self.reporter.invert_diff:
276
 
            target_lines = self.work_tree.get_file_lines(file_id)
 
331
            target_lines = work_tree_lines
277
332
        else:
278
333
            target_lines = self.target_tree.get_file_lines(file_id)
279
 
        textfile.check_text_lines(self.work_tree.get_file_lines(file_id))
 
334
        textfile.check_text_lines(work_tree_lines)
280
335
        textfile.check_text_lines(target_lines)
281
336
        parsed = self.get_parsed_patch(file_id, self.reporter.invert_diff)
282
337
        final_hunks = []
285
340
            self.diff_writer.write(parsed.get_header())
286
341
            for hunk in parsed.hunks:
287
342
                self.diff_writer.write(str(hunk))
288
 
                selected = self.prompt_bool(self.reporter.vocab['hunk'])
 
343
                selected = self.prompt_bool(self.reporter.vocab['hunk'],
 
344
                                            allow_editor=(self.change_editor
 
345
                                                          is not None))
289
346
                if not self.reporter.invert_diff:
290
347
                    selected = (not selected)
291
348
                if selected:
294
351
                else:
295
352
                    offset -= (hunk.mod_range - hunk.orig_range)
296
353
        sys.stdout.flush()
297
 
        if not self.reporter.invert_diff and (
298
 
            len(parsed.hunks) == len(final_hunks)):
299
 
            return 0
300
 
        if self.reporter.invert_diff and len(final_hunks) == 0:
301
 
            return 0
302
 
        patched = patches.iter_patched_from_hunks(target_lines, final_hunks)
303
 
        creator.shelve_lines(file_id, list(patched))
304
354
        if self.reporter.invert_diff:
305
 
            return len(final_hunks)
306
 
        return len(parsed.hunks) - len(final_hunks)
 
355
            change_count = len(final_hunks)
 
356
        else:
 
357
            change_count = len(parsed.hunks) - len(final_hunks)
 
358
        patched = patches.iter_patched_from_hunks(target_lines,
 
359
                                                  final_hunks)
 
360
        lines = list(patched)
 
361
        return lines, change_count
 
362
 
 
363
    def _edit_file(self, file_id, work_tree_lines):
 
364
        """
 
365
        :param file_id: id of the file to edit.
 
366
        :param work_tree_lines: Line contents of the file in the working tree.
 
367
        :return: (lines, change_region_count), where lines is the new line
 
368
            content of the file, and change_region_count is the number of
 
369
            changed regions.
 
370
        """
 
371
        lines = osutils.split_lines(self.change_editor.edit_file(file_id))
 
372
        return lines, self._count_changed_regions(work_tree_lines, lines)
 
373
 
 
374
    @staticmethod
 
375
    def _count_changed_regions(old_lines, new_lines):
 
376
        matcher = patiencediff.PatienceSequenceMatcher(None, old_lines,
 
377
                                                       new_lines)
 
378
        blocks = matcher.get_matching_blocks()
 
379
        return len(blocks) - 2
307
380
 
308
381
 
309
382
class Unshelver(object):
310
383
    """Unshelve changes into a working tree."""
311
384
 
312
385
    @classmethod
313
 
    def from_args(klass, shelf_id=None, action='apply', directory='.'):
 
386
    def from_args(klass, shelf_id=None, action='apply', directory='.',
 
387
                  write_diff_to=None):
314
388
        """Create an unshelver from commandline arguments.
315
389
 
 
390
        The returned shelver will have a tree that is locked and should
 
391
        be unlocked.
 
392
 
316
393
        :param shelf_id: Integer id of the shelf, as a string.
317
394
        :param action: action to perform.  May be 'apply', 'dry-run',
318
 
            'delete'.
 
395
            'delete', 'preview'.
319
396
        :param directory: The directory to unshelve changes into.
 
397
        :param write_diff_to: See Unshelver.__init__().
320
398
        """
321
399
        tree, path = workingtree.WorkingTree.open_containing(directory)
322
 
        manager = tree.get_shelf_manager()
323
 
        if shelf_id is not None:
324
 
            try:
325
 
                shelf_id = int(shelf_id)
326
 
            except ValueError:
327
 
                raise errors.InvalidShelfId(shelf_id)
328
 
        else:
329
 
            shelf_id = manager.last_shelf()
330
 
            if shelf_id is None:
331
 
                raise errors.BzrCommandError('No changes are shelved.')
332
 
            trace.note('Unshelving changes with id "%d".' % shelf_id)
333
 
        apply_changes = True
334
 
        delete_shelf = True
335
 
        read_shelf = True
336
 
        if action == 'dry-run':
337
 
            apply_changes = False
338
 
            delete_shelf = False
339
 
        if action == 'delete-only':
340
 
            apply_changes = False
341
 
            read_shelf = False
 
400
        tree.lock_tree_write()
 
401
        try:
 
402
            manager = tree.get_shelf_manager()
 
403
            if shelf_id is not None:
 
404
                try:
 
405
                    shelf_id = int(shelf_id)
 
406
                except ValueError:
 
407
                    raise errors.InvalidShelfId(shelf_id)
 
408
            else:
 
409
                shelf_id = manager.last_shelf()
 
410
                if shelf_id is None:
 
411
                    raise errors.BzrCommandError('No changes are shelved.')
 
412
            apply_changes = True
 
413
            delete_shelf = True
 
414
            read_shelf = True
 
415
            show_diff = False
 
416
            if action == 'dry-run':
 
417
                apply_changes = False
 
418
                delete_shelf = False
 
419
            elif action == 'preview':
 
420
                apply_changes = False
 
421
                delete_shelf = False
 
422
                show_diff = True
 
423
            elif action == 'delete-only':
 
424
                apply_changes = False
 
425
                read_shelf = False
 
426
            elif action == 'keep':
 
427
                apply_changes = True
 
428
                delete_shelf = False
 
429
        except:
 
430
            tree.unlock()
 
431
            raise
342
432
        return klass(tree, manager, shelf_id, apply_changes, delete_shelf,
343
 
                     read_shelf)
 
433
                     read_shelf, show_diff, write_diff_to)
344
434
 
345
435
    def __init__(self, tree, manager, shelf_id, apply_changes=True,
346
 
                 delete_shelf=True, read_shelf=True):
 
436
                 delete_shelf=True, read_shelf=True, show_diff=False,
 
437
                 write_diff_to=None):
347
438
        """Constructor.
348
439
 
349
440
        :param tree: The working tree to unshelve into.
353
444
            working tree.
354
445
        :param delete_shelf: If True, delete the changes from the shelf.
355
446
        :param read_shelf: If True, read the changes from the shelf.
 
447
        :param show_diff: If True, show the diff that would result from
 
448
            unshelving the changes.
 
449
        :param write_diff_to: A file-like object where the diff will be
 
450
            written to. If None, ui.ui_factory.make_output_stream() will
 
451
            be used.
356
452
        """
357
453
        self.tree = tree
358
454
        manager = tree.get_shelf_manager()
361
457
        self.apply_changes = apply_changes
362
458
        self.delete_shelf = delete_shelf
363
459
        self.read_shelf = read_shelf
 
460
        self.show_diff = show_diff
 
461
        self.write_diff_to = write_diff_to
364
462
 
365
463
    def run(self):
366
464
        """Perform the unshelving operation."""
367
 
        self.tree.lock_write()
 
465
        self.tree.lock_tree_write()
368
466
        cleanups = [self.tree.unlock]
369
467
        try:
370
468
            if self.read_shelf:
 
469
                trace.note('Using changes with id "%d".' % self.shelf_id)
371
470
                unshelver = self.manager.get_unshelver(self.shelf_id)
372
471
                cleanups.append(unshelver.finalize)
373
472
                if unshelver.message is not None:
374
473
                    trace.note('Message: %s' % unshelver.message)
375
474
                change_reporter = delta._ChangeReporter()
376
 
                task = ui.ui_factory.nested_progress_bar()
377
 
                try:
378
 
                    merger = unshelver.make_merger(task)
379
 
                    merger.change_reporter = change_reporter
380
 
                    if self.apply_changes:
381
 
                        merger.do_merge()
382
 
                    else:
383
 
                        self.show_changes(merger)
384
 
                finally:
385
 
                    task.finished()
 
475
                merger = unshelver.make_merger(None)
 
476
                merger.change_reporter = change_reporter
 
477
                if self.apply_changes:
 
478
                    merger.do_merge()
 
479
                elif self.show_diff:
 
480
                    self.write_diff(merger)
 
481
                else:
 
482
                    self.show_changes(merger)
386
483
            if self.delete_shelf:
387
484
                self.manager.delete_shelf(self.shelf_id)
 
485
                trace.note('Deleted changes with id "%d".' % self.shelf_id)
388
486
        finally:
389
487
            for cleanup in reversed(cleanups):
390
488
                cleanup()
391
489
 
 
490
    def write_diff(self, merger):
 
491
        """Write this operation's diff to self.write_diff_to."""
 
492
        tree_merger = merger.make_merger()
 
493
        tt = tree_merger.make_preview_transform()
 
494
        new_tree = tt.get_preview_tree()
 
495
        if self.write_diff_to is None:
 
496
            self.write_diff_to = ui.ui_factory.make_output_stream()
 
497
        path_encoding = osutils.get_diff_header_encoding()
 
498
        diff.show_diff_trees(merger.this_tree, new_tree, self.write_diff_to,
 
499
            path_encoding=path_encoding)
 
500
        tt.finalize()
 
501
 
392
502
    def show_changes(self, merger):
393
503
        """Show the changes that this operation specifies."""
394
504
        tree_merger = merger.make_merger()