Add functionality for deleting words

2 files changed, 88 insertions, 45 deletions

diff --git a/src/Buffer.zig b/src/Buffer.zig
index 26f9a93..8cf7dc0 100644
--- a/src/Buffer.zig
+++ b/src/Buffer.zig
@@ -90,10 +90,25 @@ pub fn backwardChar(self: *Buffer) void {
 }
 
 pub fn backwardDeleteChar(self: *Buffer) !void {
+    if (self.cx == 0 and self.cy == 0) {
+        return;
+    }
     self.backwardChar();
     return self.deleteChar();
 }
 
+pub fn backwardDeleteWord(self: *Buffer) !void {
+    const start = self.findBackwardWordStart();
+    if (start == self.cx) {
+        return self.backwardDeleteChar();
+    } else {
+        var row = &self.rows.items[self.cy];
+        row.data.replaceRangeAssumeCapacity(start, self.cx - start, &.{});
+        self.cx = start;
+        return row.update(self);
+    }
+}
+
 pub fn backwardParagraph(self: *Buffer) void {
     if (self.cy == 0) {
         return;
@@ -111,22 +126,11 @@ pub fn backwardParagraph(self: *Buffer) void {
 }
 
 pub fn backwardWord(self: *Buffer) void {
-    if (self.cx == 0) {
-        return self.backwardChar();
-    }
-
-    const chars = self.rows.items[self.cy].data.items;
-    // First we skip non-word
-    while (self.cx > 0) : (self.cx -= 1) {
-        if (std.ascii.isAlphanumeric(chars[self.cx - 1])) {
-            break;
-        }
-    }
-    // Then we skip word
-    while (self.cx > 0) : (self.cx -= 1) {
-        if (!std.ascii.isAlphanumeric(chars[self.cx - 1])) {
-            break;
-        }
+    const target = self.findBackwardWordStart();
+    if (target == self.cx) {
+        self.backwardChar();
+    } else {
+        self.cx = target;
     }
 }
 
@@ -176,6 +180,17 @@ pub fn deleteAllRows(self: *Buffer) void {
     }
 }
 
+pub fn deleteWord(self: *Buffer) !void {
+    const end = self.findForwardWordEnd();
+    if (end == self.cx) {
+        return self.deleteChar();
+    } else {
+        var row = &self.rows.items[self.cy];
+        row.data.replaceRangeAssumeCapacity(self.cx, end - self.cx, &.{});
+        return row.update(self);
+    }
+}
+
 pub fn deleteRow(self: *Buffer, at: usize) void {
     if (at == self.rows.items.len) {
         return;
@@ -295,6 +310,50 @@ pub fn drawStatusBar(self: Buffer, writer: anytype, screencols: usize) !void {
     try writer.writeAll("\x1b[m\r\n");
 }
 
+pub fn findBackwardWordStart(self: Buffer) usize {
+    if (self.cy == self.rows.items.len) {
+        return 0;
+    }
+
+    const chars = self.rows.items[self.cy].data.items;
+    var start = self.cx;
+    // First we skip non-word
+    while (start > 0) : (start -= 1) {
+        if (std.ascii.isAlphanumeric(chars[start - 1])) {
+            break;
+        }
+    }
+    // Then we skip word
+    while (start > 0) : (start -= 1) {
+        if (!std.ascii.isAlphanumeric(chars[start - 1])) {
+            break;
+        }
+    }
+    return start;
+}
+
+pub fn findForwardWordEnd(self: Buffer) usize {
+    if (self.cy == self.rows.items.len) {
+        return 0;
+    }
+
+    const chars = self.rows.items[self.cy].data.items;
+    var end = self.cx;
+    // First we skip non-word
+    while (end < chars.len) : (end += 1) {
+        if (std.ascii.isAlphanumeric(chars[end])) {
+            break;
+        }
+    }
+    // Then we skip word
+    while (end < chars.len) : (end += 1) {
+        if (!std.ascii.isAlphanumeric(chars[end])) {
+            break;
+        }
+    }
+    return end;
+}
+
 pub fn forwardChar(self: *Buffer) void {
     if (self.rows.items.len == self.cy) {
         return;
@@ -325,26 +384,11 @@ pub fn forwardParagraph(self: *Buffer) void {
 }
 
 pub fn forwardWord(self: *Buffer) void {
-    if (self.cy == self.rows.items.len) {
-        return;
-    }
-
-    const chars = self.rows.items[self.cy].data.items;
-    if (self.cx == chars.len) {
-        return self.forwardChar();
-    }
-
-    // First we skip non-word
-    while (self.cx < chars.len) : (self.cx += 1) {
-        if (std.ascii.isAlphanumeric(chars[self.cx])) {
-            break;
-        }
-    }
-    // Then we skip word
-    while (self.cx < chars.len) : (self.cx += 1) {
-        if (!std.ascii.isAlphanumeric(chars[self.cx])) {
-            break;
-        }
+    const end = self.findForwardWordEnd();
+    if (end == self.cx) {
+        self.forwardChar();
+    } else {
+        self.cx = end;
     }
 }
 
@@ -440,18 +484,12 @@ pub fn killLine(self: *Buffer) !void {
 
     var row = &self.rows.items[self.cy];
     if (self.cx == row.data.items.len) {
-        if (self.cy == self.rows.items.len - 1) {
-            return;
-        }
-
-        try row.appendString(self, self.rows.items[self.cy+1].data.items);
-        self.deleteRow(self.cy + 1);
+        return self.deleteChar();
     } else {
+        self.dirty = true;
         try row.data.resize(self.cx);
+        return row.update(self);
     }
-
-    self.dirty = true;
-    return row.update(self);
 }
 
 pub fn lineNumberDigits(self: Buffer) usize {
diff --git a/src/KeyMap.zig b/src/KeyMap.zig
index 8dca48d..15f5711 100644
--- a/src/KeyMap.zig
+++ b/src/KeyMap.zig
@@ -112,11 +112,14 @@ pub fn defaultMap(allocator: Allocator) !KeyMap {
     try map.bind(&.{Key.meta(Key.ctrl('d'))}, Buffer.backwardDeleteChar);
 
     // M-<*>
+    try map.bind(&.{Key.meta(Key.backspace)}, Buffer.backwardDeleteWord);
+    try map.bind(&.{Key.meta(Key.delete)}, Buffer.deleteWord);
     try map.bind(&.{Key.meta(Key.down)}, Buffer.forwardParagraph);
     try map.bind(&.{Key.meta(Key.left)}, Buffer.backwardWord);
     try map.bind(&.{Key.meta(Key.right)}, Buffer.forwardWord);
     try map.bind(&.{Key.meta(Key.up)}, Buffer.backwardParagraph);
     try map.bind(&.{Key.meta('b')}, Buffer.backwardWord);
+    try map.bind(&.{Key.meta('d')}, Buffer.deleteWord);
     try map.bind(&.{Key.meta('f')}, Buffer.forwardWord);
     // M-g is taken
     try map.bind(&.{Key.meta('n')}, Buffer.forwardParagraph);
@@ -125,6 +128,8 @@ pub fn defaultMap(allocator: Allocator) !KeyMap {
     try map.bind(&.{Key.meta('v')}, Buffer.pageUp);
 
     // C-<*>
+    try map.bind(&.{Key.ctrl(Key.backspace)}, Buffer.backwardDeleteWord);
+    try map.bind(&.{Key.ctrl(Key.delete)}, Buffer.deleteWord);
     try map.bind(&.{Key.ctrl(Key.down)}, Buffer.forwardParagraph);
     try map.bind(&.{Key.ctrl(Key.left)}, Buffer.backwardWord);
     try map.bind(&.{Key.ctrl(Key.right)}, Buffer.forwardWord);