First version of matchers for completion

A matcher is simply a function that matches needle to a completion item
and retruns where it matches and a score for the item.

Currently, filter_fuzzy is just an alias for filter_contains.

Author: abbec

Makefile

@@ -45,7 +45,7 @@ SOURCES = src/dged/binding.c src/dged/buffer.c src/dged/command.c src/dged/displ
 
 MAIN_SOURCES = src/main/main.c src/main/cmds.c src/main/bindings.c src/main/search-replace.c src/main/completion.c \
 			src/main/frame-hooks.c src/main/completion/buffer.c src/main/completion/command.c \
-			src/main/completion/path.c src/main/dired.c
+			src/main/completion/path.c src/main/dired.c src/main/completion/matchers.c
 
 # HACK: added to MAIN_SOURCES to not be picked up in tests
 # since they have their own implementation

src/dged/display.c

@@ -209,8 +209,10 @@ bool display_initialize(struct display *display) {
 
   display->term = term;
 
-  use_alternate_buffer(display);
-  flush_outbuf(display);
+  if (getenv("DGED_FORCE_NORMAL_BUFFER") == NULL) {
+    use_alternate_buffer(display);
+    flush_outbuf(display);
+  }
 
   return true;
 }

src/dged/s8.c

@@ -167,6 +167,54 @@ char *s8tocstr(struct s8 s) {
 
 const char *s8ascstr(struct s8 s) { return (const char *)s.s; }
 
+ssize_t s8findstr(struct s8 s, struct s8 find) {
+  if (s8empty(s) || s8empty(find)) {
+    return -1;
+  }
+
+  if (s.l < find.l) {
+    return -1;
+  }
+
+  if (s.l == find.l) {
+    return s8eq(s, find) ? 0 : -1;
+  }
+
+  /* at this point, s is longer than find */
+  for (size_t i = 0; i < s.l; ++i) {
+    uint8_t *start = &s.s[i];
+    if (s8startswith((struct s8){.s = start, .l = s.l - i}, find)) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+ssize_t s8ifindstr(struct s8 s, struct s8 find) {
+  if (s8empty(s) || s8empty(find)) {
+    return -1;
+  }
+
+  if (s.l < find.l) {
+    return -1;
+  }
+
+  if (s.l == find.l) {
+    return s8icmp(s, find) == 0 ? 0 : -1;
+  }
+
+  /* at this point, s is longer than find */
+  for (size_t i = 0; i < s.l; ++i) {
+    uint8_t *start = &s.s[i];
+    if (s8istartswith((struct s8){.s = start, .l = s.l - i}, find)) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
 bool s8startswith(struct s8 s, struct s8 prefix) {
   if (prefix.l == 0 || prefix.l > s.l) {
     return false;
@@ -175,6 +223,14 @@ bool s8startswith(struct s8 s, struct s8 prefix) {
   return memcmp(s.s, prefix.s, prefix.l) == 0;
 }
 
+bool s8istartswith(struct s8 s, struct s8 prefix) {
+  if (prefix.l == 0 || prefix.l > s.l) {
+    return false;
+  }
+
+  return memicmp(s.s, prefix.s, prefix.l) == 0;
+}
+
 bool s8endswith(struct s8 s, struct s8 suffix) {
   if (suffix.l > s.l) {
     return false;
@@ -184,6 +240,19 @@ bool s8endswith(struct s8 s, struct s8 suffix) {
   return memcmp(s.s + ldiff, suffix.s, suffix.l) == 0;
 }
 
+bool s8iendswith(struct s8 s, struct s8 suffix) {
+  if (suffix.l > s.l) {
+    return false;
+  }
+
+  size_t ldiff = s.l - suffix.l;
+  struct s8 tail = {
+      .s = s.s + ldiff,
+      .l = s.l - ldiff,
+  };
+  return s8icmp(tail, suffix) == 0;
+}
+
 struct s8 s8dup(struct s8 s) {
   struct s8 new = {0};
 

src/dged/s8.h

@@ -24,11 +24,15 @@ const char *s8ascstr(struct s8 s);
 
 uint8_t s8at(struct s8 s, size_t index);
 ssize_t s8find(struct s8 s, uint8_t c);
+ssize_t s8findstr(struct s8 s, struct s8 find);
+ssize_t s8ifindstr(struct s8 s, struct s8 find);
 bool s8eq(struct s8 s1, struct s8 s2);
 int s8cmp(struct s8 s1, struct s8 s2);
 int s8icmp(struct s8 s1, struct s8 s2);
 bool s8startswith(struct s8 s, struct s8 prefix);
+bool s8istartswith(struct s8 s, struct s8 prefix);
 bool s8endswith(struct s8 s, struct s8 suffix);
+bool s8iendswith(struct s8 s, struct s8 prefix);
 struct s8 s8dup(struct s8 s);
 bool s8empty(struct s8 s);
 bool s8onlyws(struct s8 s);

src/dged/window.h

@@ -2,10 +2,9 @@
 #define _WINDOW_H
 
 #include <stdbool.h>
+#include <stddef.h>
 #include <stdint.h>
 
-#include "btree.h"
-
 struct command_list;
 struct display;
 struct keymap;

src/main/cmds.c

@@ -56,6 +56,7 @@ int32_t unimplemented_command(struct command_ctx ctx, int argc,
                               const char *argv[]) {
   (void)argc;
   (void)argv;
+
   minibuffer_echo("TODO: %s is not implemented", (const char *)ctx.userdata);
   return 0;
 }

src/main/completion.c

@@ -200,11 +200,6 @@ static void clear_completions(struct completion_state *state) {
   }
 
   VEC_CLEAR(&state->completions);
-
-  if (completion_active()) {
-    buffer_view_goto(window_buffer_view(popup_window()),
-                     (struct location){0, 0});
-  }
 }
 
 static void update_window_position(struct completion_state *state) {
@@ -244,6 +239,12 @@ static void update_window_position(struct completion_state *state) {
   size_t available = window_width(root_wind) - xpos - 5;
   max_width = max_width >= available ? available : max_width;
 
+  // if we are opening anew, let's start on the first item
+  if (!popup_window_visible()) {
+    buffer_view_goto(window_buffer_view(popup_window()),
+                     (struct location){0, 0});
+  }
+
   windows_show_popup(ypos, xpos, max_width, height);
 }
 

src/main/completion/buffer.c

@@ -2,11 +2,13 @@
 
 #include <string.h>
 
+#include "completion/matchers.h"
 #include "dged/buffer.h"
 #include "dged/buffer_view.h"
 #include "dged/buffers.h"
 #include "dged/minibuffer.h"
 
+#include "dged/vec.h"
 #include "main/completion.h"
 
 static bool is_space(const struct codepoint *c) {
@@ -19,6 +21,9 @@ typedef void (*on_buffer_selected_cb)(struct buffer *);
 struct buffer_completion {
   struct buffer *buffer;
   on_buffer_selected_cb on_buffer_selected;
+  size_t match_begin;
+  size_t match_end;
+  size_t score;
 };
 
 struct buffer_provider_data {
@@ -52,31 +57,35 @@ static void buffer_comp_cleanup(void *data) {
   free(bc);
 }
 
-struct needle_match_ctx {
-  const char *needle;
-  struct completion *completions;
-  uint32_t max_ncompletions;
-  uint32_t ncompletions;
+typedef VEC(struct completion) completion_vec;
+
+struct buffer_completions {
+  completion_vec *completions;
   on_buffer_selected_cb on_buffer_selected;
+  struct s8 needle;
 };
 
-static void buffer_matches(struct buffer *buffer, void *userdata) {
-  struct needle_match_ctx *ctx = (struct needle_match_ctx *)userdata;
-
-  if (strncmp(ctx->needle, buffer->name, strlen(ctx->needle)) == 0 &&
-      ctx->ncompletions < ctx->max_ncompletions) {
+static void fill_buffer_completions(struct buffer *buffer, void *userdata) {
+  struct buffer_completions *ctx = (struct buffer_completions *)userdata;
 
+  size_t match_begin, match_end;
+  uint32_t score;
+  if (filter_contains(ctx->needle, s8(buffer->name), &match_begin, &match_end,
+                      &score)) {
     struct buffer_completion *comp_data =
         calloc(1, sizeof(struct buffer_completion));
     comp_data->buffer = buffer;
     comp_data->on_buffer_selected = ctx->on_buffer_selected;
-    ctx->completions[ctx->ncompletions] = (struct completion){
+    comp_data->match_begin = match_begin;
+    comp_data->match_end = match_end;
+
+    struct completion comp = (struct completion){
         .render = buffer_comp_render,
         .selected = buffer_comp_selected,
         .cleanup = buffer_comp_cleanup,
         .data = comp_data,
     };
-    ++ctx->ncompletions;
+    VEC_PUSH(ctx->completions, comp);
   }
 }
 
@@ -110,20 +119,18 @@ static void buffer_complete(struct completion_context ctx, bool deletion,
     free(txt.text);
   }
 
-  struct completion *completions = calloc(50, sizeof(struct completion));
-
-  struct needle_match_ctx match_ctx = (struct needle_match_ctx){
-      .needle = needle,
-      .max_ncompletions = 50,
-      .completions = completions,
-      .ncompletions = 0,
+  completion_vec completions;
+  VEC_INIT(&completions, 32);
+  struct buffer_completions match_ctx = (struct buffer_completions){
+      .completions = &completions,
       .on_buffer_selected = pd->on_buffer_selected,
+      .needle = s8(needle),
   };
 
-  buffers_for_each(buffers, buffer_matches, &match_ctx);
-  ctx.add_completions(match_ctx.completions, match_ctx.ncompletions);
-  free(completions);
+  buffers_for_each(buffers, fill_buffer_completions, &match_ctx);
   free(needle);
+  ctx.add_completions(VEC_ENTRIES(&completions), VEC_SIZE(&completions));
+  VEC_DESTROY(&completions);
 }
 
 static void cleanup_provider(void *data) {

src/main/completion/command.c

@@ -3,12 +3,14 @@
 #include <stdbool.h>
 #include <string.h>
 
+#include "completion/matchers.h"
 #include "dged/buffer.h"
 #include "dged/buffer_view.h"
 #include "dged/command.h"
 #include "dged/minibuffer.h"
 #include "dged/utf8.h"
 
+#include "dged/vec.h"
 #include "main/completion.h"
 
 static bool is_space(const struct codepoint *c) {
@@ -21,6 +23,8 @@ typedef void (*on_command_selected_cb)(struct command *);
 struct command_completion {
   struct command *command;
   on_command_selected_cb on_command_selected;
+  size_t match_begin;
+  size_t match_end;
 };
 
 struct command_provider_data {
@@ -55,31 +59,35 @@ static void command_comp_cleanup(void *data) {
   free(cc);
 }
 
-struct needle_match_ctx {
-  const char *needle;
-  struct completion *completions;
-  uint32_t max_ncompletions;
-  uint32_t ncompletions;
+typedef VEC(struct completion) completion_vec;
+
+struct buffer_completions {
+  completion_vec *completions;
   on_command_selected_cb on_command_selected;
+  struct s8 needle;
 };
 
-static void command_matches(struct command *command, void *userdata) {
-  struct needle_match_ctx *ctx = (struct needle_match_ctx *)userdata;
-
-  if (strncmp(ctx->needle, command->name, strlen(ctx->needle)) == 0 &&
-      ctx->ncompletions < ctx->max_ncompletions) {
+static void fill_commands(struct command *command, void *userdata) {
+  struct buffer_completions *ctx = (struct buffer_completions *)userdata;
 
+  size_t match_begin, match_end;
+  uint32_t score;
+  if (filter_contains(ctx->needle, s8(command->name), &match_begin, &match_end,
+                      &score)) {
     struct command_completion *comp_data =
         calloc(1, sizeof(struct command_completion));
     comp_data->command = command;
     comp_data->on_command_selected = ctx->on_command_selected;
-    ctx->completions[ctx->ncompletions] = (struct completion){
+    comp_data->match_begin = match_begin;
+    comp_data->match_end = match_end;
+
+    struct completion comp = (struct completion){
         .render = command_comp_render,
         .selected = command_comp_selected,
         .cleanup = command_comp_cleanup,
         .data = comp_data,
     };
-    ++ctx->ncompletions;
+    VEC_PUSH(ctx->completions, comp);
   }
 }
 
@@ -113,19 +121,18 @@ static void command_complete(struct completion_context ctx, bool deletion,
     free(txt.text);
   }
 
-  struct completion *completions = calloc(50, sizeof(struct completion));
+  completion_vec completions;
+  VEC_INIT(&completions, 32);
 
-  struct needle_match_ctx match_ctx = (struct needle_match_ctx){
-      .needle = needle,
-      .max_ncompletions = 50,
-      .completions = completions,
-      .ncompletions = 0,
+  struct buffer_completions match_ctx = (struct buffer_completions){
+      .completions = &completions,
       .on_command_selected = pd->on_command_selected,
+      .needle = s8(needle),
   };
 
-  commands_for_each(commands, command_matches, &match_ctx);
-  ctx.add_completions(match_ctx.completions, match_ctx.ncompletions);
-  free(completions);
+  commands_for_each(commands, fill_commands, &match_ctx);
+  ctx.add_completions(VEC_ENTRIES(&completions), VEC_SIZE(&completions));
+  VEC_DESTROY(&completions);
   free(needle);
 }