38
class ShelfReporter(object):
40
vocab = {'add file': 'Shelve adding file "%(path)s"?',
41
'binary': 'Shelve binary changes?',
42
'change kind': 'Shelve changing "%s" from %(other)s'
44
'delete file': 'Shelve removing file "%(path)s"?',
45
'final': 'Shelve %d change(s)?',
47
'modify target': 'Shelve changing target of'
48
' "%(path)s" from "%(other)s" to "%(this)s"?',
49
'rename': 'Shelve renaming "%(other)s" =>'
56
self.delta_reporter = delta._ChangeReporter()
59
"""Report that no changes were selected to apply."""
60
trace.warning('No changes to shelve.')
62
def shelved_id(self, shelf_id):
63
"""Report the id changes were shelved to."""
64
trace.note('Changes shelved with id "%d".' % shelf_id)
66
def changes_destroyed(self):
67
"""Report that changes were made without shelving."""
68
trace.note('Selected changes destroyed.')
70
def selected_changes(self, transform):
71
"""Report the changes that were selected."""
72
trace.note("Selected changes:")
73
changes = transform.iter_changes()
74
delta.report_changes(changes, self.delta_reporter)
76
def prompt_change(self, change):
77
"""Determine the prompt for a change to apply."""
78
if change[0] == 'rename':
79
vals = {'this': change[3], 'other': change[2]}
80
elif change[0] == 'change kind':
81
vals = {'path': change[4], 'other': change[2], 'this': change[3]}
82
elif change[0] == 'modify target':
83
vals = {'path': change[2], 'other': change[3], 'this': change[4]}
85
vals = {'path': change[3]}
86
prompt = self.vocab[change[0]] % vals
90
class ApplyReporter(ShelfReporter):
92
vocab = {'add file': 'Delete file "%(path)s"?',
93
'binary': 'Apply binary changes?',
94
'change kind': 'Change "%(path)s" from %(this)s'
96
'delete file': 'Add file "%(path)s"?',
97
'final': 'Apply %d change(s)?',
98
'hunk': 'Apply change?',
99
'modify target': 'Change target of'
100
' "%(path)s" from "%(this)s" to "%(other)s"?',
101
'rename': 'Rename "%(this)s" => "%(other)s"?',
106
def changes_destroyed(self):
38
110
class Shelver(object):
39
111
"""Interactively shelve the changes in a working tree."""
41
113
def __init__(self, work_tree, target_tree, diff_writer=None, auto=False,
42
114
auto_apply=False, file_list=None, message=None,
115
destroy=False, manager=None, reporter=None):
46
118
:param work_tree: The working tree to shelve changes from.
52
124
:param message: The message to associate with the shelved changes.
53
125
:param destroy: Change the working tree without storing the shelved
127
:param manager: The shelf manager to use.
128
:param reporter: Object for reporting changes to user.
56
130
self.work_tree = work_tree
57
131
self.target_tree = target_tree
58
132
self.diff_writer = diff_writer
59
133
if self.diff_writer is None:
60
134
self.diff_writer = sys.stdout
61
self.manager = work_tree.get_shelf_manager()
136
manager = work_tree.get_shelf_manager()
137
self.manager = manager
63
139
self.auto_apply = auto_apply
64
140
self.file_list = file_list
65
141
self.message = message
66
142
self.destroy = destroy
144
reporter = ShelfReporter()
145
self.reporter = reporter
69
148
def from_args(klass, diff_writer, revision=None, all=False, file_list=None,
70
149
message=None, directory='.', destroy=False):
71
150
"""Create a shelver from commandline arguments.
152
The returned shelver wil have a work_tree that is locked and should
73
155
:param revision: RevisionSpec of the revision to compare to.
74
156
:param all: If True, shelve all changes without prompting.
75
157
:param file_list: If supplied, only files in this list may be shelved.
81
163
tree, path = workingtree.WorkingTree.open_containing(directory)
82
target_tree = builtins._get_one_revision_tree('shelf2', revision,
84
files = builtins.safe_relpath_files(tree, file_list)
164
# Ensure that tree is locked for the lifetime of target_tree, as
165
# target tree may be reading from the same dirstate.
166
tree.lock_tree_write()
168
target_tree = builtins._get_one_revision_tree('shelf2', revision,
170
files = builtins.safe_relpath_files(tree, file_list)
85
174
return klass(tree, target_tree, diff_writer, all, all, files, message,
98
187
changes_shelved += self.handle_modify_text(creator,
100
189
except errors.BinaryFile:
101
if self.prompt_bool('Shelve binary changes?'):
190
if self.prompt_bool(self.reporter.vocab['binary']):
102
191
changes_shelved += 1
103
192
creator.shelve_content_change(change[1])
104
if change[0] == 'add file':
105
if self.prompt_bool('Shelve adding file "%s"?'
107
creator.shelve_creation(change[1])
109
if change[0] == 'delete file':
110
if self.prompt_bool('Shelve removing file "%s"?'
112
creator.shelve_deletion(change[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])
119
if change[0] == 'rename':
120
if self.prompt_bool('Shelve renaming "%s" => "%s"?' %
122
creator.shelve_rename(change[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])
194
if self.prompt_bool(self.reporter.prompt_change(change)):
195
creator.shelve_change(change)
128
196
changes_shelved += 1
129
197
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)
198
self.reporter.selected_changes(creator.work_transform)
134
199
if (self.auto_apply or self.prompt_bool(
135
'Shelve %d change(s)?' % changes_shelved)):
200
self.reporter.vocab['final'] % changes_shelved)):
137
202
creator.transform()
138
trace.note('Selected changes destroyed.')
203
self.reporter.changes_destroyed()
140
205
shelf_id = self.manager.shelve_changes(creator,
142
trace.note('Changes shelved with id "%d".' % shelf_id)
207
self.reporter.shelved_id(shelf_id)
144
trace.warning('No changes to shelve.')
209
self.reporter.no_changes()
146
211
shutil.rmtree(self.tempdir)
147
212
creator.finalize()
149
def get_parsed_patch(self, file_id):
214
def get_parsed_patch(self, file_id, invert=False):
150
215
"""Return a parsed version of a file's patch.
152
217
:param file_id: The id of the file to generate a patch for.
218
:param invert: If True, provide an inverted patch (insertions displayed
219
as removals, removals displayed as insertions).
153
220
:return: A patches.Patch.
155
old_path = self.target_tree.id2path(file_id)
156
new_path = self.work_tree.id2path(file_id)
157
222
diff_file = StringIO()
158
text_differ = diff.DiffText(self.target_tree, self.work_tree,
224
old_tree = self.work_tree
225
new_tree = self.target_tree
227
old_tree = self.target_tree
228
new_tree = self.work_tree
229
old_path = old_tree.id2path(file_id)
230
new_path = new_tree.id2path(file_id)
231
text_differ = diff.DiffText(old_tree, new_tree, diff_file)
160
232
patch = text_differ.diff(file_id, old_path, new_path, 'file', 'file')
161
233
diff_file.seek(0)
162
234
return patches.parse_patch(diff_file)
203
275
def handle_modify_text(self, creator, file_id):
204
276
"""Provide diff hunk selection for modified text.
278
If self.reporter.invert_diff is True, the diff is inverted so that
279
insertions are displayed as removals and vice versa.
206
281
:param creator: a ShelfCreator
207
282
:param file_id: The id of the file to shelve.
208
283
:return: number of shelved hunks.
210
target_lines = self.target_tree.get_file_lines(file_id)
285
if self.reporter.invert_diff:
286
target_lines = self.work_tree.get_file_lines(file_id)
288
target_lines = self.target_tree.get_file_lines(file_id)
211
289
textfile.check_text_lines(self.work_tree.get_file_lines(file_id))
212
290
textfile.check_text_lines(target_lines)
213
parsed = self.get_parsed_patch(file_id)
291
parsed = self.get_parsed_patch(file_id, self.reporter.invert_diff)
215
293
if not self.auto:
217
295
self.diff_writer.write(parsed.get_header())
218
296
for hunk in parsed.hunks:
219
297
self.diff_writer.write(str(hunk))
220
if not self.prompt_bool('Shelve?'):
298
selected = self.prompt_bool(self.reporter.vocab['hunk'])
299
if not self.reporter.invert_diff:
300
selected = (not selected)
221
302
hunk.mod_pos += offset
222
303
final_hunks.append(hunk)
224
305
offset -= (hunk.mod_range - hunk.orig_range)
225
306
sys.stdout.flush()
226
if len(parsed.hunks) == len(final_hunks):
307
if not self.reporter.invert_diff and (
308
len(parsed.hunks) == len(final_hunks)):
310
if self.reporter.invert_diff and len(final_hunks) == 0:
228
312
patched = patches.iter_patched_from_hunks(target_lines, final_hunks)
229
313
creator.shelve_lines(file_id, list(patched))
314
if self.reporter.invert_diff:
315
return len(final_hunks)
230
316
return len(parsed.hunks) - len(final_hunks)
237
323
def from_args(klass, shelf_id=None, action='apply', directory='.'):
238
324
"""Create an unshelver from commandline arguments.
326
The returned shelver wil have a tree that is locked and should
240
329
:param shelf_id: Integer id of the shelf, as a string.
241
330
:param action: action to perform. May be 'apply', 'dry-run',
243
332
:param directory: The directory to unshelve changes into.
245
334
tree, path = workingtree.WorkingTree.open_containing(directory)
246
manager = tree.get_shelf_manager()
247
if shelf_id is not None:
249
shelf_id = int(shelf_id)
251
raise errors.InvalidShelfId(shelf_id)
253
shelf_id = manager.last_shelf()
255
raise errors.BzrCommandError('No changes are shelved.')
256
trace.note('Unshelving changes with id "%d".' % shelf_id)
260
if action == 'dry-run':
261
apply_changes = False
263
if action == 'delete-only':
264
apply_changes = False
335
tree.lock_tree_write()
337
manager = tree.get_shelf_manager()
338
if shelf_id is not None:
340
shelf_id = int(shelf_id)
342
raise errors.InvalidShelfId(shelf_id)
344
shelf_id = manager.last_shelf()
346
raise errors.BzrCommandError('No changes are shelved.')
347
trace.note('Unshelving changes with id "%d".' % shelf_id)
351
if action == 'dry-run':
352
apply_changes = False
354
if action == 'delete-only':
355
apply_changes = False
266
360
return klass(tree, manager, shelf_id, apply_changes, delete_shelf,