wipmatchers

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,30 @@ 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;
+}
+
 bool s8startswith(struct s8 s, struct s8 prefix) {
   if (prefix.l == 0 || prefix.l > s.l) {
     return false;

src/dged/s8.h

@@ -24,6 +24,7 @@ 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);
 bool s8eq(struct s8 s1, struct s8 s2);
 int s8cmp(struct s8 s1, struct s8 s2);
 int s8icmp(struct s8 s1, struct s8 s2);

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

@@ -1,3 +1,6 @@
+#include "dged/s8.h"
+#include "dged/vec.h"
+#include <stdlib.h>
 #define _DEFAULT_SOURCE
 #include "completion.h"
 
@@ -32,6 +35,9 @@ struct buffer_completion {
 struct completion_item {
   struct region area;
   struct completion completion;
+  uint32_t score;
+  size_t match_begin;
+  size_t match_end;
 };
 
 static struct completion_state {
@@ -300,16 +306,55 @@ static void open_completion(struct completion_state *state) {
   run_next_frame(update_window_pos_frame_hook, state);
 }
 
-static void add_completions_impl(struct completion *completions,
+static int compare_completions(const void *c1, const void *c2) {
+  struct completion_item *comp1 = (struct completion_item *)c1;
+  struct completion_item *comp2 = (struct completion_item *)c2;
+
+  return comp1->score > comp2->score ? -1
+         : comp1->score < comp2->score
+             ? 1
+             : s8cmp(comp1->completion.sort_text(comp1->completion.data),
+                     comp2->completion.sort_text(comp2->completion.data));
+}
+
+static void sort_completions(struct completion_state *state) {
+
+  qsort(VEC_ENTRIES(&state->completions), VEC_SIZE(&state->completions),
+        sizeof(struct completion_item), compare_completions);
+}
+
+static void add_completions_impl(struct s8 needle, filter_fn filter,
+                                 struct completion *completions,
                                  size_t ncompletions) {
+  if (ncompletions == 0) {
+    return;
+  }
+
   for (uint32_t i = 0; i < ncompletions; ++i) {
     struct completion *c = &completions[i];
-    struct region area = c->render(c->data, g_state.completions_buffer);
-    VEC_APPEND(&g_state.completions, struct completion_item * new);
-    new->area = area;
-    new->completion = *c;
+
+    size_t match_begin, match_end;
+    uint32_t score;
+    if (filter(needle, c->filter_text(c->data), &match_begin, &match_end,
+               &score)) {
+      VEC_APPEND(&g_state.completions, struct completion_item * new);
+      new->completion = *c;
+      new->score = score;
+      new->match_begin = match_begin;
+      new->match_end = match_end;
+    } else {
+      if (c->cleanup != NULL) {
+        c->cleanup(c->data);
+      }
+    }
   }
 
+  sort_completions(&g_state);
+  VEC_FOR_EACH(&g_state.completions, struct completion_item * item) {
+    struct region area = item->completion.render(item->completion.data,
+                                                 g_state.completions_buffer);
+    item->area = area;
+  }
   open_completion(&g_state);
 }
 
@@ -348,6 +393,7 @@ static void update_comp_buffer(struct buffer *buffer, void *userdata) {
 
   if (buffer_is_empty(buffer)) {
     abort_completion();
+    return;
   }
 
   struct region reg = active_completion_region(state);

src/main/completion.h

@@ -14,18 +14,35 @@ struct buffers;
 struct buffer_view;
 struct commands;
 
+typedef struct s8 str8;
+
 typedef struct region (*completion_render_fn)(void *, struct buffer *);
 typedef void (*completion_selected_fn)(void *, struct buffer_view *);
 typedef void (*completion_cleanup_fn)(void *);
+typedef str8 (*completion_filter_text_fn)(void *);
+typedef str8 (*completion_sort_text_fn)(void *);
 
 struct completion {
   void *data;
   completion_render_fn render;
   completion_selected_fn selected;
   completion_cleanup_fn cleanup;
+  completion_filter_text_fn filter_text;
+  completion_sort_text_fn sort_text;
 };
 
-typedef void (*add_completions)(struct completion *, size_t);
+typedef bool (*filter_fn)(struct s8 needle, struct s8 item, size_t *match_begin,
+                          size_t *match_end, uint32_t *score);
+
+typedef void (*add_completions)(struct s8, filter_fn filter,
+                                struct completion *, size_t);
+
+bool filter_startswith(struct s8 needle, struct s8 item, size_t *match_begin,
+                       size_t *match_end, uint32_t *score);
+bool filter_contains(struct s8 needle, struct s8 item, size_t *match_begin,
+                     size_t *match_end, uint32_t *score);
+bool filter_fuzzy(struct s8 needle, struct s8 item, size_t *match_begin,
+                  size_t *match_end, uint32_t *score);
 
 /**
  * Context for calculating completions.

src/main/completion/buffer.c

@@ -7,6 +7,7 @@
 #include "dged/buffers.h"
 #include "dged/minibuffer.h"
 
+#include "dged/vec.h"
 #include "main/completion.h"
 
 static bool is_space(const struct codepoint *c) {
@@ -47,37 +48,39 @@ static struct region buffer_comp_render(void *data,
   return region_new(begin, end);
 }
 
+static struct s8 buffer_comp_filter_text(void *data) {
+  struct buffer_completion *bc = (struct buffer_completion *)data;
+  return s8(bc->buffer->name);
+}
+
 static void buffer_comp_cleanup(void *data) {
   struct buffer_completion *bc = (struct buffer_completion *)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;
 };
 
-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) {
-
-    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){
-        .render = buffer_comp_render,
-        .selected = buffer_comp_selected,
-        .cleanup = buffer_comp_cleanup,
-        .data = comp_data,
-    };
-    ++ctx->ncompletions;
-  }
+static void fill_buffer_completions(struct buffer *buffer, void *userdata) {
+  struct buffer_completions *ctx = (struct buffer_completions *)userdata;
+
+  struct buffer_completion *comp_data =
+      calloc(1, sizeof(struct buffer_completion));
+  comp_data->buffer = buffer;
+  comp_data->on_buffer_selected = ctx->on_buffer_selected;
+
+  struct completion comp = (struct completion){
+      .render = buffer_comp_render,
+      .selected = buffer_comp_selected,
+      .cleanup = buffer_comp_cleanup,
+      .data = comp_data,
+      .filter_text = buffer_comp_filter_text,
+  };
+  VEC_PUSH(ctx->completions, comp);
 }
 
 static void buffer_complete(struct completion_context ctx, bool deletion,
@@ -110,19 +113,17 @@ 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,
   };
 
-  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);
+  ctx.add_completions(s8(needle), filter_contains, VEC_ENTRIES(&completions),
+                      VEC_SIZE(&completions));
+  VEC_DESTROY(&completions);
   free(needle);
 }
 

src/main/completion/command.c

@@ -9,6 +9,7 @@
 #include "dged/minibuffer.h"
 #include "dged/utf8.h"
 
+#include "dged/vec.h"
 #include "main/completion.h"
 
 static bool is_space(const struct codepoint *c) {
@@ -50,37 +51,38 @@ static struct region command_comp_render(void *data,
   return region_new(begin, end);
 }
 
+static struct s8 command_comp_filter_text(struct command_completion *comp) {
+  return s8(comp->command->name);
+}
+
 static void command_comp_cleanup(void *data) {
   struct command_completion *cc = (struct command_completion *)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;
 };
 
-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) {
-
-    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){
-        .render = command_comp_render,
-        .selected = command_comp_selected,
-        .cleanup = command_comp_cleanup,
-        .data = comp_data,
-    };
-    ++ctx->ncompletions;
-  }
+static void fill_commands(struct command *command, void *userdata) {
+  struct buffer_completions *ctx = (struct buffer_completions *)userdata;
+
+  struct command_completion *comp_data =
+      calloc(1, sizeof(struct command_completion));
+  comp_data->command = command;
+  comp_data->on_command_selected = ctx->on_command_selected;
+  struct completion comp = (struct completion){
+      .render = command_comp_render,
+      .selected = command_comp_selected,
+      .cleanup = command_comp_cleanup,
+      .data = comp_data,
+      .filter_text = (completion_filter_text_fn)command_comp_filter_text,
+      .sort_text = (completion_sort_text_fn)command_comp_filter_text,
+  };
+  VEC_PUSH(ctx->completions, comp);
 }
 
 static void command_complete(struct completion_context ctx, bool deletion,
@@ -113,19 +115,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,
   };
 
-  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(s8(needle), filter_contains, VEC_ENTRIES(&completions),
+                      VEC_SIZE(&completions));
+  VEC_DESTROY(&completions);
   free(needle);
 }