Debian Codegraph @

Lib/_pyrepl/commands.py

raw
1 # Copyright 2000-2010 Michael Hudson-Doyle <[email protected]>
2 # Antonio Cuni
3 # Armin Rigo
4 #
5 # All Rights Reserved
6 #
7 #
8 # Permission to use, copy, modify, and distribute this software and
9 # its documentation for any purpose is hereby granted without fee,
10 # provided that the above copyright notice appear in all copies and
11 # that both that copyright notice and this permission notice appear in
12 # supporting documentation.
13 #
14 # THE AUTHOR MICHAEL HUDSON DISCLAIMS ALL WARRANTIES WITH REGARD TO
15 # THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
16 # AND FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,
17 # INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
18 # RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
19 # CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
20 # CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21
22 from __future__ import annotations
23 import os
24 import time
25
26 # Categories of actions:
27 # killing
28 # yanking
29 # motion
30 # editing
31 # history
32 # finishing
33 # [completion]
34
35 from .trace import trace
36
37 # types
38 if False:
39 from .historical_reader import HistoricalReader
40
41
42 class Command:
43 finish: bool = False
44 kills_digit_arg: bool = True
45
46 def __init__(
47 self, reader: HistoricalReader, event_name: str, event: list[str]
48 ) -> None:
49 # Reader should really be "any reader" but there's too much usage of
50 # HistoricalReader methods and fields in the code below for us to
51 # refactor at the moment.
52
53 self.reader = reader
54 self.event = event
55 self.event_name = event_name
56
57 def do(self) -> None:
58 pass
59
60
61 class KillCommand(Command):
62 def kill_range(self, start: int, end: int) -> None:
63 if start == end:
64 return
65 r = self.reader
66 b = r.buffer
67 text = b[start:end]
68 del b[start:end]
69 if is_kill(r.last_command):
70 if start < r.pos:
71 r.kill_ring[-1] = text + r.kill_ring[-1]
72 else:
73 r.kill_ring[-1] = r.kill_ring[-1] + text
74 else:
75 r.kill_ring.append(text)
76 r.pos = start
77 r.dirty = True
78
79
80 class YankCommand(Command):
81 pass
82
83
84 class MotionCommand(Command):
85 pass
86
87
88 class EditCommand(Command):
89 pass
90
91
92 class FinishCommand(Command):
93 finish = True
94 pass
95
96
97 def is_kill(command: type[Command] | None) -> bool:
98 return command is not None and issubclass(command, KillCommand)
99
100
101 def is_yank(command: type[Command] | None) -> bool:
102 return command is not None and issubclass(command, YankCommand)
103
104
105 # etc
106
107
108 class digit_arg(Command):
109 kills_digit_arg = False
110
111 def do(self) -> None:
112 r = self.reader
113 c = self.event[-1]
114 if c == "-":
115 if r.arg is not None:
116 r.arg = -r.arg
117 else:
118 r.arg = -1
119 else:
120 d = int(c)
121 if r.arg is None:
122 r.arg = d
123 else:
124 if r.arg < 0:
125 r.arg = 10 * r.arg - d
126 else:
127 r.arg = 10 * r.arg + d
128 r.dirty = True
129
130
131 class clear_screen(Command):
132 def do(self) -> None:
133 r = self.reader
134 r.console.clear()
135 r.dirty = True
136
137
138 class refresh(Command):
139 def do(self) -> None:
140 self.reader.dirty = True
141
142
143 class repaint(Command):
144 def do(self) -> None:
145 self.reader.dirty = True
146 self.reader.console.repaint()
147
148
149 class kill_line(KillCommand):
150 def do(self) -> None:
151 r = self.reader
152 b = r.buffer
153 eol = r.eol()
154 for c in b[r.pos : eol]:
155 if not c.isspace():
156 self.kill_range(r.pos, eol)
157 return
158 else:
159 self.kill_range(r.pos, eol + 1)
160
161
162 class unix_line_discard(KillCommand):
163 def do(self) -> None:
164 r = self.reader
165 self.kill_range(r.bol(), r.pos)
166
167
168 class unix_word_rubout(KillCommand):
169 def do(self) -> None:
170 r = self.reader
171 for i in range(r.get_arg()):
172 self.kill_range(r.bow(), r.pos)
173
174
175 class kill_word(KillCommand):
176 def do(self) -> None:
177 r = self.reader
178 for i in range(r.get_arg()):
179 self.kill_range(r.pos, r.eow())
180
181
182 class backward_kill_word(KillCommand):
183 def do(self) -> None:
184 r = self.reader
185 for i in range(r.get_arg()):
186 self.kill_range(r.bow(), r.pos)
187
188
189 class yank(YankCommand):
190 def do(self) -> None:
191 r = self.reader
192 if not r.kill_ring:
193 r.error("nothing to yank")
194 return
195 r.insert(r.kill_ring[-1])
196
197
198 class yank_pop(YankCommand):
199 def do(self) -> None:
200 r = self.reader
201 b = r.buffer
202 if not r.kill_ring:
203 r.error("nothing to yank")
204 return
205 if not is_yank(r.last_command):
206 r.error("previous command was not a yank")
207 return
208 repl = len(r.kill_ring[-1])
209 r.kill_ring.insert(0, r.kill_ring.pop())
210 t = r.kill_ring[-1]
211 b[r.pos - repl : r.pos] = t
212 r.pos = r.pos - repl + len(t)
213 r.dirty = True
214
215
216 class interrupt(FinishCommand):
217 def do(self) -> None:
218 import signal
219
220 self.reader.console.finish()
221 self.reader.finish()
222 os.kill(os.getpid(), signal.SIGINT)
223
224
225 class ctrl_c(Command):
226 def do(self) -> None:
227 self.reader.console.finish()
228 self.reader.finish()
229 raise KeyboardInterrupt
230
231
232 class suspend(Command):
233 def do(self) -> None:
234 import signal
235
236 r = self.reader
237 p = r.pos
238 r.console.finish()
239 os.kill(os.getpid(), signal.SIGSTOP)
240 ## this should probably be done
241 ## in a handler for SIGCONT?
242 r.console.prepare()
243 r.pos = p
244 # r.posxy = 0, 0 # XXX this is invalid
245 r.dirty = True
246 r.console.screen = []
247
248
249 class up(MotionCommand):
250 def do(self) -> None:
251 r = self.reader
252 for _ in range(r.get_arg()):
253 x, y = r.pos2xy()
254 new_y = y - 1
255
256 if r.bol() == 0:
257 if r.historyi > 0:
258 r.select_item(r.historyi - 1)
259 return
260 r.pos = 0
261 r.error("start of buffer")
262 return
263
264 if (
265 x
266 > (
267 new_x := r.max_column(new_y)
268 ) # we're past the end of the previous line
269 or x == r.max_column(y)
270 and any(
271 not i.isspace() for i in r.buffer[r.bol() :]
272 ) # move between eols
273 ):
274 x = new_x
275
276 r.setpos_from_xy(x, new_y)
277
278
279 class down(MotionCommand):
280 def do(self) -> None:
281 r = self.reader
282 b = r.buffer
283 for _ in range(r.get_arg()):
284 x, y = r.pos2xy()
285 new_y = y + 1
286
287 if r.eol() == len(b):
288 if r.historyi < len(r.history):
289 r.select_item(r.historyi + 1)
290 r.pos = r.eol(0)
291 return
292 r.pos = len(b)
293 r.error("end of buffer")
294 return
295
296 if (
297 x
298 > (
299 new_x := r.max_column(new_y)
300 ) # we're past the end of the previous line
301 or x == r.max_column(y)
302 and any(
303 not i.isspace() for i in r.buffer[r.bol() :]
304 ) # move between eols
305 ):
306 x = new_x
307
308 r.setpos_from_xy(x, new_y)
309
310
311 class left(MotionCommand):
312 def do(self) -> None:
313 r = self.reader
314 for _ in range(r.get_arg()):
315 p = r.pos - 1
316 if p >= 0:
317 r.pos = p
318 else:
319 self.reader.error("start of buffer")
320
321
322 class right(MotionCommand):
323 def do(self) -> None:
324 r = self.reader
325 b = r.buffer
326 for _ in range(r.get_arg()):
327 p = r.pos + 1
328 if p <= len(b):
329 r.pos = p
330 else:
331 self.reader.error("end of buffer")
332
333
334 class beginning_of_line(MotionCommand):
335 def do(self) -> None:
336 self.reader.pos = self.reader.bol()
337
338
339 class end_of_line(MotionCommand):
340 def do(self) -> None:
341 self.reader.pos = self.reader.eol()
342
343
344 class home(MotionCommand):
345 def do(self) -> None:
346 self.reader.pos = 0
347
348
349 class end(MotionCommand):
350 def do(self) -> None:
351 self.reader.pos = len(self.reader.buffer)
352
353
354 class forward_word(MotionCommand):
355 def do(self) -> None:
356 r = self.reader
357 for i in range(r.get_arg()):
358 r.pos = r.eow()
359
360
361 class backward_word(MotionCommand):
362 def do(self) -> None:
363 r = self.reader
364 for i in range(r.get_arg()):
365 r.pos = r.bow()
366
367
368 class self_insert(EditCommand):
369 def do(self) -> None:
370 r = self.reader
371 text = self.event * r.get_arg()
372 r.insert(text)
373 if r.paste_mode:
374 data = ""
375 ev = r.console.getpending()
376 data += ev.data
377 if data:
378 r.insert(data)
379 r.last_refresh_cache.invalidated = True
380
381
382 class insert_nl(EditCommand):
383 def do(self) -> None:
384 r = self.reader
385 r.insert("\n" * r.get_arg())
386
387
388 class transpose_characters(EditCommand):
389 def do(self) -> None:
390 r = self.reader
391 b = r.buffer
392 s = r.pos - 1
393 if s < 0:
394 r.error("cannot transpose at start of buffer")
395 else:
396 if s == len(b):
397 s -= 1
398 t = min(s + r.get_arg(), len(b) - 1)
399 c = b[s]
400 del b[s]
401 b.insert(t, c)
402 r.pos = t
403 r.dirty = True
404
405
406 class backspace(EditCommand):
407 def do(self) -> None:
408 r = self.reader
409 b = r.buffer
410 for i in range(r.get_arg()):
411 if r.pos > 0:
412 r.pos -= 1
413 del b[r.pos]
414 r.dirty = True
415 else:
416 self.reader.error("can't backspace at start")
417
418
419 class delete(EditCommand):
420 def do(self) -> None:
421 r = self.reader
422 b = r.buffer
423 if self.event[-1] == "\004":
424 if b and b[-1].endswith("\n"):
425 self.finish = True
426 elif (
427 r.pos == 0
428 and len(b) == 0 # this is something of a hack
429 ):
430 r.update_screen()
431 r.console.finish()
432 raise EOFError
433
434 for i in range(r.get_arg()):
435 if r.pos != len(b):
436 del b[r.pos]
437 r.dirty = True
438 else:
439 self.reader.error("end of buffer")
440
441
442 class accept(FinishCommand):
443 def do(self) -> None:
444 pass
445
446
447 class help(Command):
448 def do(self) -> None:
449 import _sitebuiltins
450
451 with self.reader.suspend():
452 self.reader.msg = _sitebuiltins._Helper()() # type: ignore[assignment]
453
454
455 class invalid_key(Command):
456 def do(self) -> None:
457 pending = self.reader.console.getpending()
458 s = "".join(self.event) + pending.data
459 self.reader.error("`%r' not bound" % s)
460
461
462 class invalid_command(Command):
463 def do(self) -> None:
464 s = self.event_name
465 self.reader.error("command `%s' not known" % s)
466
467
468 class show_history(Command):
469 def do(self) -> None:
470 from .pager import get_pager
471 from site import gethistoryfile
472
473 history = os.linesep.join(self.reader.history[:])
474 self.reader.console.restore()
475 pager = get_pager()
476 pager(history, gethistoryfile())
477 self.reader.console.prepare()
478
479 # We need to copy over the state so that it's consistent between
480 # console and reader, and console does not overwrite/append stuff
481 self.reader.console.screen = self.reader.screen.copy()
482 self.reader.console.posxy = self.reader.cxy
483
484
485 class paste_mode(Command):
486 def do(self) -> None:
487 self.reader.paste_mode = not self.reader.paste_mode
488 self.reader.dirty = True
489
490
491 class perform_bracketed_paste(Command):
492 def do(self) -> None:
493 done = "\x1b[201~"
494 data = ""
495 start = time.time()
496 while done not in data:
497 ev = self.reader.console.getpending()
498 data += ev.data
499 trace(
500 "bracketed pasting of {l} chars done in {s:.2f}s",
501 l=len(data),
502 s=time.time() - start,
503 )
504 self.reader.insert(data.replace(done, ""))
505 self.reader.last_refresh_cache.invalidated = True