yank working!

thomasballinger · thomasballinger · commit c92b043d7111 · 2014-08-26T19:14:26.000-07:00
diff --git a/bpython/curtsiesfrontend/manual_readline.py b/bpython/curtsiesfrontend/manual_readline.py
@@ -17,7 +17,6 @@ class AbstractEdits(object):
             'line': 'hello world',
             'cursor_offset': 5,
             'cut_buffer': 'there',
-            'indent': 4,
             }
 
     def __contains__(self, key):
@@ -28,15 +27,22 @@ def __contains__(self, key):
         else:
             return True
 
-    def add(self, key, func):
+    def add(self, key, func, overwrite=False):
         if key in self:
-            raise ValueError('key %r already has a mapping' % (key,))
+            if overwrite:
+                del self[key]
+            else:
+                raise ValueError('key %r already has a mapping' % (key,))
         params = inspect.getargspec(func)[0]
         args = dict((k, v) for k, v in self.default_kwargs.items() if k in params)
         r = func(**args)
         if len(r) == 2:
+            if hasattr(func, 'kills'):
+                raise ValueError('function %r returns two values, but has a kills attribute' % (func,))
             self.simple_edits[key] = func
         elif len(r) == 3:
+            if not hasattr(func, 'kills'):
+                raise ValueError('function %r returns three values, but has no kills attribute' % (func,))
             self.cut_buffer_edits[key] = func
         else:
             raise ValueError('return type of function %r not recognized' % (func,))
@@ -52,11 +58,20 @@ def call(self, key, **kwargs):
         args = dict((k, v) for k, v in kwargs.items() if k in params)
         return func(**args)
 
+    def call_without_cut(self, key, **kwargs):
+        """Looks up the function and calls it, returning only line and cursor offset"""
+        r = self.call_for_two(key, **kwargs)
+        return r[:2]
+
     def __getitem__(self, key):
         if key in self.simple_edits: return self.simple_edits[key]
         if key in self.cut_buffer_edits: return self.cut_buffer_edits[key]
         raise KeyError("key %r not mapped" % (key,))
 
+    def __delitem__(self, key):
+        if key in self.simple_edits: del self.simple_edits[key]
+        elif key in self.cut_buffer_edits: del self.cut_buffer_edits[key]
+        else: raise KeyError("key %r not mapped" % (key,))
 
 class UnconfiguredEdits(AbstractEdits):
     """Maps key to edit functions, and bins them by what parameters they take.
@@ -104,7 +119,8 @@ def __init__(self, simple_edits, cut_buffer_edits, awaiting_config, config, key_
         self.simple_edits = dict(simple_edits)
         self.cut_buffer_edits = dict(cut_buffer_edits)
         for attr, func in awaiting_config.items():
-            super(ConfiguredEdits, self).add(key_dispatch[getattr(config, attr)], func)
+            for key in key_dispatch[getattr(config, attr)]:
+                super(ConfiguredEdits, self).add(key, func, overwrite=True)
 
     def add_config_attr(self, config_attr, func):
         raise NotImplementedError("Config already set on this mapping")
@@ -117,6 +133,14 @@ def add(self, key, func):
 # Because the edits.on decorator runs the functions, functions which depend
 # on other functions must be declared after their dependencies
 
+def kills_behind(func):
+    func.kills = 'behind'
+    return func
+
+def kills_ahead(func):
+    func.kills = 'ahead'
+    return func
+
 @edit_keys.on('<Ctrl-b>')
 @edit_keys.on('<LEFT>')
 def left_arrow(cursor_offset, line):
@@ -183,22 +207,29 @@ def delete_from_cursor_back(cursor_offset, line):
     return 0, line[cursor_offset:]
 
 @edit_keys.on('<Esc+d>') # option-d
+@kills_ahead
 def delete_rest_of_word(cursor_offset, line):
     m = re.search(r'\w\b', line[cursor_offset:])
     if not m:
-        return cursor_offset, line
-    return cursor_offset, line[:cursor_offset] + line[m.start()+cursor_offset+1:]
+        return cursor_offset, line, ''
+    return (cursor_offset, line[:cursor_offset] + line[m.start()+cursor_offset+1:],
+            line[cursor_offset:m.start()+cursor_offset+1])
 
 @edit_keys.on('<Ctrl-w>')
 @edit_keys.on(config='clear_word_key')
+@kills_behind
 def delete_word_to_cursor(cursor_offset, line):
     matches = list(re.finditer(r'\s\S', line[:cursor_offset]))
     start = matches[-1].start()+1 if matches else 0
-    return start, line[:start] + line[cursor_offset:]
+    return start, line[:start] + line[cursor_offset:], line[start:cursor_offset]
 
 @edit_keys.on('<Esc+y>')
-def yank_prev_prev_killed_text(cursor_offset, line):
-    return cursor_offset, line #TODO Not implemented
+def yank_prev_prev_killed_text(cursor_offset, line, cut_buffer): #TODO not implemented - just prev
+    return cursor_offset+len(cut_buffer), line[:cursor_offset] + cut_buffer + line[cursor_offset:]
+
+@edit_keys.on(config='yank_from_buffer_key')
+def yank_prev_killed_text(cursor_offset, line, cut_buffer):
+    return cursor_offset+len(cut_buffer), line[:cursor_offset] + cut_buffer + line[cursor_offset:]
 
 @edit_keys.on('<Ctrl-t>')
 def transpose_character_before_cursor(cursor_offset, line):
@@ -223,21 +254,24 @@ def uppercase_next_word(cursor_offset, line):
     return cursor_offset, line #TODO Not implemented
 
 @edit_keys.on('<Ctrl-k>')
+@kills_ahead
 def delete_from_cursor_forward(cursor_offset, line):
-    return cursor_offset, line[:cursor_offset]
+    return cursor_offset, line[:cursor_offset], line[cursor_offset:]
 
 @edit_keys.on('<Esc+c>')
 def titlecase_next_word(cursor_offset, line):
     return cursor_offset, line #TODO Not implemented
 
 @edit_keys.on('<Esc+BACKSPACE>')
 @edit_keys.on('<Meta-BACKSPACE>')
+@kills_behind
 def delete_word_from_cursor_back(cursor_offset, line):
     """Whatever my option-delete does in bash on my mac"""
     if not line:
         return cursor_offset, line
     starts = [m.start() for m in list(re.finditer(r'\b\w', line)) if m.start() < cursor_offset]
     if starts:
-        return starts[-1], line[:starts[-1]] + line[cursor_offset:]
-    return cursor_offset, line
+        return starts[-1], line[:starts[-1]] + line[cursor_offset:], line[starts[-1]:cursor_offset]
+    return cursor_offset, line, ''
+
 
diff --git a/bpython/curtsiesfrontend/repl.py b/bpython/curtsiesfrontend/repl.py
@@ -458,12 +458,17 @@ def process_key_event(self, e):
             self.up_one_line()
         elif e in ("<DOWN>",) + key_dispatch[self.config.down_one_line_key]:
             self.down_one_line()
-        elif e in self.edit_keys:
-            self.cursor_offset, self.current_line = self.edit_keys[e](self.cursor_offset, self.current_line)
+        elif e in ("<Ctrl-d>",):
+            self.on_control_d()
+        elif e in self.edit_keys.cut_buffer_edits:
+            self.readline_kill(e)
+        elif e in self.edit_keys.simple_edits:
+            self.cursor_offset, self.current_line = self.edit_keys.call(e,
+                    cursor_offset=self.cursor_offset,
+                    line=self.current_line,
+                    cut_buffer=self.cut_buffer)
         elif e in key_dispatch[self.config.cut_to_buffer_key]:
             self.cut_to_buffer()
-        elif e in key_dispatch[self.config.yank_from_buffer_key]:
-            self.yank_from_buffer()
         elif e in key_dispatch[self.config.reimport_key]:
             self.clear_modules_and_reevaluate()
         elif e in key_dispatch[self.config.toggle_file_watch_key]:
@@ -476,8 +481,6 @@ def process_key_event(self, e):
             self.pager(self.help_text())
         elif e in key_dispatch[self.config.suspend_key]:
             raise SystemExit()
-        elif e in ("<Ctrl-d>",):
-            self.on_control_d()
         elif e in key_dispatch[self.config.exit_key]:
             raise SystemExit()
         elif e in ("\n", "\r", "<PADENTER>", "<Ctrl-j>", "<Ctrl-m>"):
@@ -504,6 +507,16 @@ def process_key_event(self, e):
         else:
             self.add_normal_character(e)
 
+    def readline_kill(self, e):
+        func = self.edit_keys[e]
+        self.cursor_offset, self.current_line, cut = func(self.cursor_offset, self.current_line)
+        if self.last_events[-2] == e: # consecutive kill commands are cumulative
+            if func.kills == 'ahead': self.cut_buffer += cut
+            elif func.kills == 'behind': self.cut_buffer = cut + self.cut_buffer
+            else: raise ValueError("cut had value other than 'ahead' or 'behind'")
+        else:
+            self.cut_buffer = cut
+
     def on_enter(self, insert_into_history=True):
         self.cursor_offset = -1 # so the cursor isn't touching a paren
         self.unhighlight_paren()        # in unhighlight_paren
diff --git a/bpython/test/test_manual_readline.py b/bpython/test/test_manual_readline.py
@@ -243,6 +243,11 @@ class config: att = 'c'
         self.assertEqual(configured_edits.call('c', cursor_offset=5, line='asfd'),
                          ('hi', 2))
 
+    def test_actual(self):
+        class config: att = 'c'
+        key_dispatch = {'c': 'c'}
+        configured_edits = self.edits.mapping_with_config(config, key_dispatch)
+
 
 if __name__ == '__main__':
     unittest.main()
