← 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
 
 
43
class ShelfReporter(object):
 
44
 
 
45
    vocab = {'add file': 'Shelve adding file "%(path)s"?',
 
46
             'binary': 'Shelve binary changes?',
 
47
             'change kind': 'Shelve changing "%s" from %(other)s'
 
48
             ' to %(this)s?',
 
49
             'delete file': 'Shelve removing file "%(path)s"?',
 
50
             'final': 'Shelve %d change(s)?',
 
51
             'hunk': 'Shelve?',
 
52
             'modify target': 'Shelve changing target of'
 
53
             ' "%(path)s" from "%(other)s" to "%(this)s"?',
 
54
             'rename': 'Shelve renaming "%(other)s" =>'
 
55
                        ' "%(this)s"?'
 
56
             }
 
57
 
 
58
    invert_diff = False
 
59
 
 
60
    def __init__(self):
 
61
        self.delta_reporter = delta._ChangeReporter()
 
62
 
 
63
    def no_changes(self):
 
64
        """Report that no changes were selected to apply."""
 
65
        trace.warning('No changes to shelve.')
 
66
 
 
67
    def shelved_id(self, shelf_id):
 
68
        """Report the id changes were shelved to."""
 
69
        trace.note('Changes shelved with id "%d".' % shelf_id)
 
70
 
 
71
    def changes_destroyed(self):
 
72
        """Report that changes were made without shelving."""
 
73
        trace.note('Selected changes destroyed.')
 
74
 
 
75
    def selected_changes(self, transform):
 
76
        """Report the changes that were selected."""
 
77
        trace.note("Selected changes:")
 
78
        changes = transform.iter_changes()
 
79
        delta.report_changes(changes, self.delta_reporter)
 
80
 
 
81
    def prompt_change(self, change):
 
82
        """Determine the prompt for a change to apply."""
 
83
        if change[0] == 'rename':
 
84
            vals = {'this': change[3], 'other': change[2]}
 
85
        elif change[0] == 'change kind':
 
86
            vals = {'path': change[4], 'other': change[2], 'this': change[3]}
 
87
        elif change[0] == 'modify target':
 
88
            vals = {'path': change[2], 'other': change[3], 'this': change[4]}
 
89
        else:
 
90
            vals = {'path': change[3]}
 
91
        prompt = self.vocab[change[0]] % vals
 
92
        return prompt
 
93
 
 
94
 
 
95
class ApplyReporter(ShelfReporter):
 
96
 
 
97
    vocab = {'add file': 'Delete file "%(path)s"?',
 
98
             'binary': 'Apply binary changes?',
 
99
             'change kind': 'Change "%(path)s" from %(this)s'
 
100
             ' to %(other)s?',
 
101
             'delete file': 'Add file "%(path)s"?',
 
102
             'final': 'Apply %d change(s)?',
 
103
             'hunk': 'Apply change?',
 
104
             'modify target': 'Change target of'
 
105
             ' "%(path)s" from "%(this)s" to "%(other)s"?',
 
106
             'rename': 'Rename "%(this)s" => "%(other)s"?',
 
107
             }
 
108
 
 
109
    invert_diff = True
 
110
 
 
111
    def changes_destroyed(self):
 
112
        pass
 
113
 
 
114
 
38
115
class Shelver(object):
39
116
    """Interactively shelve the changes in a working tree."""
40
117
 
41
118
    def __init__(self, work_tree, target_tree, diff_writer=None, auto=False,
42
119
                 auto_apply=False, file_list=None, message=None,
43
 
                 destroy=False):
 
120
                 destroy=False, manager=None, reporter=None):
44
121
        """Constructor.
45
122
 
46
123
        :param work_tree: The working tree to shelve changes from.
52
129
        :param message: The message to associate with the shelved changes.
53
130
        :param destroy: Change the working tree without storing the shelved
54
131
            changes.
 
132
        :param manager: The shelf manager to use.
 
133
        :param reporter: Object for reporting changes to user.
55
134
        """
56
135
        self.work_tree = work_tree
57
136
        self.target_tree = target_tree
58
137
        self.diff_writer = diff_writer
59
138
        if self.diff_writer is None:
60
139
            self.diff_writer = sys.stdout
61
 
        self.manager = work_tree.get_shelf_manager()
 
140
        if manager is None:
 
141
            manager = work_tree.get_shelf_manager()
 
142
        self.manager = manager
62
143
        self.auto = auto
63
144
        self.auto_apply = auto_apply
64
145
        self.file_list = file_list
65
146
        self.message = message
66
147
        self.destroy = destroy
 
148
        if reporter is None:
 
149
            reporter = ShelfReporter()
 
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()
67
154
 
68
155
    @classmethod
69
156
    def from_args(klass, diff_writer, revision=None, all=False, file_list=None,
70
157
                  message=None, directory='.', destroy=False):
71
158
        """Create a shelver from commandline arguments.
72
159
 
 
160
        The returned shelver wil have a work_tree that is locked and should
 
161
        be unlocked.
 
162
 
73
163
        :param revision: RevisionSpec of the revision to compare to.
74
164
        :param all: If True, shelve all changes without prompting.
75
165
        :param file_list: If supplied, only files in this list may be  shelved.
79
169
            changes.
80
170
        """
81
171
        tree, path = workingtree.WorkingTree.open_containing(directory)
82
 
        target_tree = builtins._get_one_revision_tree('shelf2', revision,
83
 
            tree.branch, tree)
84
 
        files = builtins.safe_relpath_files(tree, file_list)
85
 
        return klass(tree, target_tree, diff_writer, all, all, files, message,
86
 
                     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()
87
183
 
88
184
    def run(self):
89
185
        """Interactively shelve the changes."""
98
194
                        changes_shelved += self.handle_modify_text(creator,
99
195
                                                                   change[1])
100
196
                    except errors.BinaryFile:
101
 
                        if self.prompt_bool('Shelve binary changes?'):
 
197
                        if self.prompt_bool(self.reporter.vocab['binary']):
102
198
                            changes_shelved += 1
103
199
                            creator.shelve_content_change(change[1])
104
 
                if change[0] == 'add file':
105
 
                    if self.prompt_bool('Shelve adding file "%s"?'
106
 
                                        % change[3]):
107
 
                        creator.shelve_creation(change[1])
108
 
                        changes_shelved += 1
109
 
                if change[0] == 'delete file':
110
 
                    if self.prompt_bool('Shelve removing file "%s"?'
111
 
                                        % change[3]):
112
 
                        creator.shelve_deletion(change[1])
113
 
                        changes_shelved += 1
114
 
                if change[0] == 'change kind':
115
 
                    if self.prompt_bool('Shelve changing "%s" from %s to %s? '
116
 
                                        % (change[4], change[2], change[3])):
117
 
                        creator.shelve_content_change(change[1])
118
 
                        changes_shelved += 1
119
 
                if change[0] == 'rename':
120
 
                    if self.prompt_bool('Shelve renaming "%s" => "%s"?' %
121
 
                                   change[2:]):
122
 
                        creator.shelve_rename(change[1])
123
 
                        changes_shelved += 1
124
 
                if change[0] == 'modify target':
125
 
                    if self.prompt_bool('Shelve changing target of "%s" '
126
 
                            'from "%s" to "%s"?' % change[2:]):
127
 
                        creator.shelve_modify_target(change[1])
 
200
                else:
 
201
                    if self.prompt_bool(self.reporter.prompt_change(change)):
 
202
                        creator.shelve_change(change)
128
203
                        changes_shelved += 1
129
204
            if changes_shelved > 0:
130
 
                trace.note("Selected changes:")
131
 
                changes = creator.work_transform.iter_changes()
132
 
                reporter = delta._ChangeReporter()
133
 
                delta.report_changes(changes, reporter)
 
205
                self.reporter.selected_changes(creator.work_transform)
134
206
                if (self.auto_apply or self.prompt_bool(
135
 
                    'Shelve %d change(s)?' % changes_shelved)):
 
207
                    self.reporter.vocab['final'] % changes_shelved)):
136
208
                    if self.destroy:
137
209
                        creator.transform()
138
 
                        trace.note('Selected changes destroyed.')
 
210
                        self.reporter.changes_destroyed()
139
211
                    else:
140
212
                        shelf_id = self.manager.shelve_changes(creator,
141
213
                                                               self.message)
142
 
                        trace.note('Changes shelved with id "%d".' % shelf_id)
 
214
                        self.reporter.shelved_id(shelf_id)
143
215
            else:
144
 
                trace.warning('No changes to shelve.')
 
216
                self.reporter.no_changes()
145
217
        finally:
146
218
            shutil.rmtree(self.tempdir)
147
219
            creator.finalize()
148
220
 
149
 
    def get_parsed_patch(self, file_id):
 
221
    def finalize(self):
 
222
        if self.change_editor is not None:
 
223
            self.change_editor.finish()
 
224
        self.work_tree.unlock()
 
225
 
 
226
 
 
227
    def get_parsed_patch(self, file_id, invert=False):
150
228
        """Return a parsed version of a file's patch.
151
229
 
152
230
        :param file_id: The id of the file to generate a patch for.
 
231
        :param invert: If True, provide an inverted patch (insertions displayed
 
232
            as removals, removals displayed as insertions).
153
233
        :return: A patches.Patch.
154
234
        """
155
 
        old_path = self.target_tree.id2path(file_id)
156
 
        new_path = self.work_tree.id2path(file_id)
157
235
        diff_file = StringIO()
158
 
        text_differ = diff.DiffText(self.target_tree, self.work_tree,
159
 
                                    diff_file)
 
236
        if invert:
 
237
            old_tree = self.work_tree
 
238
            new_tree = self.target_tree
 
239
        else:
 
240
            old_tree = self.target_tree
 
241
            new_tree = self.work_tree
 
242
        old_path = old_tree.id2path(file_id)
 
243
        new_path = new_tree.id2path(file_id)
 
244
        text_differ = diff.DiffText(old_tree, new_tree, diff_file,
 
245
            path_encoding=osutils.get_terminal_encoding())
160
246
        patch = text_differ.diff(file_id, old_path, new_path, 'file', 'file')
161
247
        diff_file.seek(0)
162
248
        return patches.parse_patch(diff_file)
167
253
        :param message: The message to prompt a user with.
168
254
        :return: A character.
169
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.")
170
262
        sys.stdout.write(message)
171
263
        char = osutils.getchar()
172
264
        sys.stdout.write("\r" + ' ' * len(message) + '\r')
173
265
        sys.stdout.flush()
174
266
        return char
175
267
 
176
 
    def prompt_bool(self, question, long=False):
 
268
    def prompt_bool(self, question, long=False, allow_editor=False):
177
269
        """Prompt the user with a yes/no question.
178
270
 
179
271
        This may be overridden by self.auto.  It may also *set* self.auto.  It
183
275
        """
184
276
        if self.auto:
185
277
            return True
 
278
        editor_string = ''
186
279
        if long:
187
 
            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
188
283
        else:
189
 
            prompt = ' [yNfq?]'
 
284
            if allow_editor:
 
285
                editor_string = 'e'
 
286
            prompt = ' [yN%sfq?]' % editor_string
190
287
        char = self.prompt(question + prompt)
191
288
        if char == 'y':
192
289
            return True
 
290
        elif char == 'e' and allow_editor:
 
291
            raise UseEditor
193
292
        elif char == 'f':
194
293
            self.auto = True
195
294
            return True
201
300
            return False
202
301
 
203
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):
204
320
        """Provide diff hunk selection for modified text.
205
321
 
 
322
        If self.reporter.invert_diff is True, the diff is inverted so that
 
323
        insertions are displayed as removals and vice versa.
 
324
 
206
325
        :param creator: a ShelfCreator
207
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.
208
328
        :return: number of shelved hunks.
209
329
        """
210
 
        target_lines = self.target_tree.get_file_lines(file_id)
211
 
        textfile.check_text_lines(self.work_tree.get_file_lines(file_id))
 
330
        if self.reporter.invert_diff:
 
331
            target_lines = work_tree_lines
 
332
        else:
 
333
            target_lines = self.target_tree.get_file_lines(file_id)
 
334
        textfile.check_text_lines(work_tree_lines)
212
335
        textfile.check_text_lines(target_lines)
213
 
        parsed = self.get_parsed_patch(file_id)
 
336
        parsed = self.get_parsed_patch(file_id, self.reporter.invert_diff)
214
337
        final_hunks = []
215
338
        if not self.auto:
216
339
            offset = 0
217
340
            self.diff_writer.write(parsed.get_header())
218
341
            for hunk in parsed.hunks:
219
342
                self.diff_writer.write(str(hunk))
220
 
                if not self.prompt_bool('Shelve?'):
 
343
                selected = self.prompt_bool(self.reporter.vocab['hunk'],
 
344
                                            allow_editor=(self.change_editor
 
345
                                                          is not None))
 
346
                if not self.reporter.invert_diff:
 
347
                    selected = (not selected)
 
348
                if selected:
221
349
                    hunk.mod_pos += offset
222
350
                    final_hunks.append(hunk)
223
351
                else:
224
352
                    offset -= (hunk.mod_range - hunk.orig_range)
225
353
        sys.stdout.flush()
226
 
        if len(parsed.hunks) == len(final_hunks):
227
 
            return 0
228
 
        patched = patches.iter_patched_from_hunks(target_lines, final_hunks)
229
 
        creator.shelve_lines(file_id, list(patched))
230
 
        return len(parsed.hunks) - len(final_hunks)
 
354
        if self.reporter.invert_diff:
 
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
231
380
 
232
381
 
233
382
class Unshelver(object):
234
383
    """Unshelve changes into a working tree."""
235
384
 
236
385
    @classmethod
237
 
    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):
238
388
        """Create an unshelver from commandline arguments.
239
389
 
 
390
        The returned shelver will have a tree that is locked and should
 
391
        be unlocked.
 
392
 
240
393
        :param shelf_id: Integer id of the shelf, as a string.
241
394
        :param action: action to perform.  May be 'apply', 'dry-run',
242
 
            'delete'.
 
395
            'delete', 'preview'.
243
396
        :param directory: The directory to unshelve changes into.
 
397
        :param write_diff_to: See Unshelver.__init__().
244
398
        """
245
399
        tree, path = workingtree.WorkingTree.open_containing(directory)
246
 
        manager = tree.get_shelf_manager()
247
 
        if shelf_id is not None:
248
 
            try:
249
 
                shelf_id = int(shelf_id)
250
 
            except ValueError:
251
 
                raise errors.InvalidShelfId(shelf_id)
252
 
        else:
253
 
            shelf_id = manager.last_shelf()
254
 
            if shelf_id is None:
255
 
                raise errors.BzrCommandError('No changes are shelved.')
256
 
            trace.note('Unshelving changes with id "%d".' % shelf_id)
257
 
        apply_changes = True
258
 
        delete_shelf = True
259
 
        read_shelf = True
260
 
        if action == 'dry-run':
261
 
            apply_changes = False
262
 
            delete_shelf = False
263
 
        if action == 'delete-only':
264
 
            apply_changes = False
265
 
            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
266
432
        return klass(tree, manager, shelf_id, apply_changes, delete_shelf,
267
 
                     read_shelf)
 
433
                     read_shelf, show_diff, write_diff_to)
268
434
 
269
435
    def __init__(self, tree, manager, shelf_id, apply_changes=True,
270
 
                 delete_shelf=True, read_shelf=True):
 
436
                 delete_shelf=True, read_shelf=True, show_diff=False,
 
437
                 write_diff_to=None):
271
438
        """Constructor.
272
439
 
273
440
        :param tree: The working tree to unshelve into.
277
444
            working tree.
278
445
        :param delete_shelf: If True, delete the changes from the shelf.
279
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.
280
452
        """
281
453
        self.tree = tree
282
454
        manager = tree.get_shelf_manager()
285
457
        self.apply_changes = apply_changes
286
458
        self.delete_shelf = delete_shelf
287
459
        self.read_shelf = read_shelf
 
460
        self.show_diff = show_diff
 
461
        self.write_diff_to = write_diff_to
288
462
 
289
463
    def run(self):
290
464
        """Perform the unshelving operation."""
291
 
        self.tree.lock_write()
 
465
        self.tree.lock_tree_write()
292
466
        cleanups = [self.tree.unlock]
293
467
        try:
294
468
            if self.read_shelf:
 
469
                trace.note('Using changes with id "%d".' % self.shelf_id)
295
470
                unshelver = self.manager.get_unshelver(self.shelf_id)
296
471
                cleanups.append(unshelver.finalize)
297
472
                if unshelver.message is not None:
298
473
                    trace.note('Message: %s' % unshelver.message)
299
474
                change_reporter = delta._ChangeReporter()
300
 
                task = ui.ui_factory.nested_progress_bar()
301
 
                try:
302
 
                    merger = unshelver.make_merger(task)
303
 
                    merger.change_reporter = change_reporter
304
 
                    if self.apply_changes:
305
 
                        merger.do_merge()
306
 
                    else:
307
 
                        self.show_changes(merger)
308
 
                finally:
309
 
                    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)
310
483
            if self.delete_shelf:
311
484
                self.manager.delete_shelf(self.shelf_id)
 
485
                trace.note('Deleted changes with id "%d".' % self.shelf_id)
312
486
        finally:
313
487
            for cleanup in reversed(cleanups):
314
488
                cleanup()
315
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
 
316
502
    def show_changes(self, merger):
317
503
        """Show the changes that this operation specifies."""
318
504
        tree_merger = merger.make_merger()