Rearrange code and cleanup

include/boxes/diagnostics.h

@@ -0,0 +1,20 @@
+#ifndef BOXES_DIAGNOSTICS_H
+#define BOXES_DIAGNOSTICS_H
+
+#include "editor/decl.h"
+#include "io/ui.h"
+#include "pch.h"
+#include "utils/utils.h"
+
+struct DiagnosticBox {
+  std::vector<VWarn> warnings;
+  std::vector<ScreenCell> cells;
+  uint32_t box_width;
+  uint32_t box_height;
+
+  void clear();
+  void render_first();
+  void render(Coord pos);
+};
+
+#endif

include/boxes/hover.h

@@ -1,11 +1,11 @@
-#ifndef HOVER_H
-#define HOVER_H
+#ifndef BOXES_HOVER_H
+#define BOXES_HOVER_H
 
-#include "./pch.h"
-#include "./spans.h"
-#include "./ts_def.h"
-#include "./ui.h"
-#include "./utils.h"
+#include "editor/decl.h"
+#include "io/ui.h"
+#include "pch.h"
+#include "ts/decl.h"
+#include "utils/utils.h"
 
 struct HoverBox {
   std::string text;
@@ -23,15 +23,4 @@ struct HoverBox {
   void render(Coord pos);
 };
 
-struct DiagnosticBox {
-  std::vector<VWarn> warnings;
-  std::vector<ScreenCell> cells;
-  uint32_t box_width;
-  uint32_t box_height;
-
-  void clear();
-  void render_first();
-  void render(Coord pos);
-};
-
 #endif

include/config.h

@@ -1,9 +1,9 @@
-#ifndef MAPS_H
-#define MAPS_H
+#ifndef CONFIG_H
+#define CONFIG_H
 
-#include "./lsp.h"
-#include "./pch.h"
-#include "./ts_def.h"
+#include "lsp/lsp.h"
+#include "pch.h"
+#include "ts/decl.h"
 
 static const std::unordered_map<uint8_t, LSP> kLsps = {
     {1,

include/editor/decl.h

@@ -0,0 +1,45 @@
+#ifndef EDITOR_DECL_H
+#define EDITOR_DECL_H
+
+#include "utils/utils.h"
+
+struct Fold {
+  uint32_t start;
+  uint32_t end;
+
+  bool contains(uint32_t line) const { return line >= start && line <= end; }
+  bool operator<(const Fold &other) const { return start < other.start; }
+};
+
+struct Span {
+  uint32_t start;
+  uint32_t end;
+  Highlight *hl;
+
+  bool operator<(const Span &other) const { return start < other.start; }
+};
+
+struct VWarn {
+  uint32_t line;
+  std::string text;
+  std::string text_full;
+  std::string source;
+  std::string code;
+  std::vector<std::string> see_also;
+  int8_t type;
+  uint32_t start;
+  uint32_t end{UINT32_MAX};
+
+  bool operator<(const VWarn &other) const { return line < other.line; }
+};
+
+struct VAI {
+  Coord pos;
+  char *text;
+  uint32_t len;
+  uint32_t lines; // number of \n in text for speed .. the ai part will not
+                  // line wrap but multiline ones need to have its own lines
+                  // after the first one
+};
+
+#endif

include/editor/editor.h

@@ -1,13 +1,13 @@
 #ifndef EDITOR_H
 #define EDITOR_H
 
-#include "./hover.h"
-#include "./knot.h"
-#include "./pch.h"
-#include "./spans.h"
-#include "./ts_def.h"
-#include "./ui.h"
-#include "./utils.h"
+#include "boxes/diagnostics.h"
+#include "boxes/hover.h"
+#include "editor/spans.h"
+#include "io/knot.h"
+#include "io/ui.h"
+#include "ts/decl.h"
+#include "utils/utils.h"
 
 #define CHAR 0
 #define WORD 1
@@ -51,66 +51,8 @@ struct Editor {
   int lsp_version = 1;
 };
 
-inline const Fold *fold_for_line(const std::vector<Fold> &folds,
-                                 uint32_t line) {
-  auto it = std::lower_bound(
-      folds.begin(), folds.end(), line,
-      [](const Fold &fold, uint32_t value) { return fold.start < value; });
-  if (it != folds.end() && it->start == line)
-    return &(*it);
-  if (it != folds.begin()) {
-    --it;
-    if (it->contains(line))
-      return &(*it);
-  }
-  return nullptr;
-}
-
-inline Fold *fold_for_line(std::vector<Fold> &folds, uint32_t line) {
-  const auto *fold =
-      fold_for_line(static_cast<const std::vector<Fold> &>(folds), line);
-  return const_cast<Fold *>(fold);
-}
-
-inline bool line_is_fold_start(const std::vector<Fold> &folds, uint32_t line) {
-  const Fold *fold = fold_for_line(folds, line);
-  return fold && fold->start == line;
-}
-
-inline bool line_is_folded(const std::vector<Fold> &folds, uint32_t line) {
-  return fold_for_line(folds, line) != nullptr;
-}
-
-inline uint32_t next_unfolded_row(const Editor *editor, uint32_t row) {
-  uint32_t limit = editor && editor->root ? editor->root->line_count : 0;
-  while (row < limit) {
-    const Fold *fold = fold_for_line(editor->folds, row);
-    if (!fold)
-      return row;
-    row = fold->end + 1;
-  }
-  return limit;
-}
-
-inline uint32_t prev_unfolded_row(const Editor *editor, uint32_t row) {
-  while (row > 0) {
-    const Fold *fold = fold_for_line(editor->folds, row);
-    if (!fold)
-      return row;
-    if (fold->start == 0)
-      return 0;
-    row = fold->start - 1;
-  }
-  return 0;
-}
-
-void apply_edit(std::vector<Span> &spans, uint32_t x, int64_t y);
-void apply_hook_insertion(Editor *editor, uint32_t line, uint32_t rows);
-void apply_hook_deletion(Editor *editor, uint32_t removal_start,
-                         uint32_t removal_end);
 Editor *new_editor(const char *filename_arg, Coord position, Coord size);
 void save_file(Editor *editor);
-void hover_diagnostic(Editor *editor);
 void free_editor(Editor *editor);
 void render_editor(Editor *editor);
 void fold(Editor *editor, uint32_t start_line, uint32_t end_line);
@@ -144,12 +86,22 @@ void word_boundaries_exclusive(Editor *editor, Coord coord, uint32_t *prev_col,
 std::vector<Fold>::iterator find_fold_iter(Editor *editor, uint32_t line);
 bool add_fold(Editor *editor, uint32_t start, uint32_t end);
 bool remove_fold(Editor *editor, uint32_t line);
-void apply_line_insertion(Editor *editor, uint32_t line, uint32_t rows);
-void apply_line_deletion(Editor *editor, uint32_t removal_start,
-                         uint32_t removal_end);
 uint32_t leading_indent(const char *line, uint32_t len);
 uint32_t get_indent(Editor *editor, Coord cursor);
 bool closing_after_cursor(const char *line, uint32_t len, uint32_t col);
 void editor_lsp_handle(Editor *editor, json msg);
 
+inline void apply_hook_insertion(Editor *editor, uint32_t line, uint32_t rows) {
+  for (auto &hook : editor->hooks)
+    if (hook > line)
+      hook += rows;
+}
+
+inline void apply_hook_deletion(Editor *editor, uint32_t removal_start,
+                                uint32_t removal_end) {
+  for (auto &hook : editor->hooks)
+    if (hook > removal_start)
+      hook -= removal_end - removal_start + 1;
+}
+
 #endif

include/editor/folds.h

@@ -0,0 +1,150 @@
+#ifndef EDITOR_FOLDS_H
+#define EDITOR_FOLDS_H
+
+#include "editor/editor.h"
+
+inline std::vector<Fold>::iterator find_fold_iter(Editor *editor,
+                                                  uint32_t line) {
+  auto &folds = editor->folds;
+  auto it = std::lower_bound(
+      folds.begin(), folds.end(), line,
+      [](const Fold &fold, uint32_t value) { return fold.start < value; });
+  if (it != folds.end() && it->start == line)
+    return it;
+  if (it != folds.begin()) {
+    --it;
+    if (it->contains(line))
+      return it;
+  }
+  return folds.end();
+}
+
+inline bool add_fold(Editor *editor, uint32_t start, uint32_t end) {
+  if (!editor || !editor->root)
+    return false;
+  if (start > end)
+    std::swap(start, end);
+  if (start >= editor->root->line_count)
+    return false;
+  end = std::min(end, editor->root->line_count - 1);
+  if (start == end)
+    return false;
+  Fold new_fold{start, end};
+  auto &folds = editor->folds;
+  auto it = std::lower_bound(
+      folds.begin(), folds.end(), new_fold.start,
+      [](const Fold &fold, uint32_t value) { return fold.start < value; });
+  if (it != folds.begin()) {
+    auto prev = std::prev(it);
+    if (prev->end + 1 >= new_fold.start) {
+      new_fold.start = std::min(new_fold.start, prev->start);
+      new_fold.end = std::max(new_fold.end, prev->end);
+      it = folds.erase(prev);
+    }
+  }
+  while (it != folds.end() && it->start <= new_fold.end + 1) {
+    new_fold.end = std::max(new_fold.end, it->end);
+    it = folds.erase(it);
+  }
+  folds.insert(it, new_fold);
+  return true;
+}
+
+inline bool remove_fold(Editor *editor, uint32_t line) {
+  auto it = find_fold_iter(editor, line);
+  if (it == editor->folds.end())
+    return false;
+  editor->folds.erase(it);
+  return true;
+}
+
+inline void apply_line_insertion(Editor *editor, uint32_t line, uint32_t rows) {
+  for (auto it = editor->folds.begin(); it != editor->folds.end();) {
+    if (line <= it->start) {
+      it->start += rows;
+      it->end += rows;
+      ++it;
+    } else if (line <= it->end) {
+      it = editor->folds.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+inline void apply_line_deletion(Editor *editor, uint32_t removal_start,
+                                uint32_t removal_end) {
+  if (removal_start > removal_end)
+    return;
+  uint32_t rows_removed = removal_end - removal_start + 1;
+  std::vector<Fold> updated;
+  updated.reserve(editor->folds.size());
+  for (auto fold : editor->folds) {
+    if (removal_end < fold.start) {
+      fold.start -= rows_removed;
+      fold.end -= rows_removed;
+      updated.push_back(fold);
+      continue;
+    }
+    if (removal_start > fold.end) {
+      updated.push_back(fold);
+      continue;
+    }
+  }
+  editor->folds.swap(updated);
+}
+
+inline const Fold *fold_for_line(const std::vector<Fold> &folds,
+                                 uint32_t line) {
+  auto it = std::lower_bound(
+      folds.begin(), folds.end(), line,
+      [](const Fold &fold, uint32_t value) { return fold.start < value; });
+  if (it != folds.end() && it->start == line)
+    return &(*it);
+  if (it != folds.begin()) {
+    --it;
+    if (it->contains(line))
+      return &(*it);
+  }
+  return nullptr;
+}
+
+inline Fold *fold_for_line(std::vector<Fold> &folds, uint32_t line) {
+  const auto *fold =
+      fold_for_line(static_cast<const std::vector<Fold> &>(folds), line);
+  return const_cast<Fold *>(fold);
+}
+
+inline bool line_is_fold_start(const std::vector<Fold> &folds, uint32_t line) {
+  const Fold *fold = fold_for_line(folds, line);
+  return fold && fold->start == line;
+}
+
+inline bool line_is_folded(const std::vector<Fold> &folds, uint32_t line) {
+  return fold_for_line(folds, line) != nullptr;
+}
+
+inline uint32_t next_unfolded_row(const Editor *editor, uint32_t row) {
+  uint32_t limit = editor && editor->root ? editor->root->line_count : 0;
+  while (row < limit) {
+    const Fold *fold = fold_for_line(editor->folds, row);
+    if (!fold)
+      return row;
+    row = fold->end + 1;
+  }
+  return limit;
+}
+
+inline uint32_t prev_unfolded_row(const Editor *editor, uint32_t row) {
+  while (row > 0) {
+    const Fold *fold = fold_for_line(editor->folds, row);
+    if (!fold)
+      return row;
+    if (fold->start == 0)
+      return 0;
+    row = fold->start - 1;
+  }
+  return 0;
+}
+
+#endif

include/editor/spans.h

@@ -1,47 +1,8 @@
-#ifndef SPANS_H
-#define SPANS_H
+#ifndef EDITOR_SPANS_H
+#define EDITOR_SPANS_H
 
-#include "./pch.h"
-#include "./utils.h"
-
-struct VWarn {
-  uint32_t line;
-  std::string text;
-  std::string text_full;
-  std::string source;
-  std::string code;
-  std::vector<std::string> see_also;
-  int8_t type;
-  uint32_t start;
-  uint32_t end{UINT32_MAX};
-
-  bool operator<(const VWarn &other) const { return line < other.line; }
-};
-
-struct VAI {
-  Coord pos;
-  char *text;
-  uint32_t len;
-  uint32_t lines; // number of \n in text for speed .. the ai part will not
-                  // line wrap but multiline ones need to have its own lines
-                  // after the first one
-};
-
-struct Fold {
-  uint32_t start;
-  uint32_t end;
-
-  bool contains(uint32_t line) const { return line >= start && line <= end; }
-  bool operator<(const Fold &other) const { return start < other.start; }
-};
-
-struct Span {
-  uint32_t start;
-  uint32_t end;
-  Highlight *hl;
-
-  bool operator<(const Span &other) const { return start < other.start; }
-};
+#include "editor/decl.h"
+#include "utils/utils.h"
 
 struct Spans {
   std::vector<Span> spans;
@@ -98,4 +59,27 @@ struct SpanCursor {
   }
 };
 
+inline void apply_edit(std::vector<Span> &spans, uint32_t x, int64_t y) {
+  Span key{.start = x, .end = 0, .hl = nullptr};
+  auto it = std::lower_bound(
+      spans.begin(), spans.end(), key,
+      [](const Span &a, const Span &b) { return a.start < b.start; });
+  size_t idx = std::distance(spans.begin(), it);
+  while (idx > 0 && spans.at(idx - 1).end >= x)
+    --idx;
+  for (size_t i = idx; i < spans.size();) {
+    Span &s = spans.at(i);
+    if (s.start < x && s.end >= x) {
+      s.end += y;
+    } else if (s.start > x) {
+      s.start += y;
+      s.end += y;
+    }
+    if (s.end <= s.start)
+      spans.erase(spans.begin() + i);
+    else
+      ++i;
+  }
+}
+
 #endif

include/io/knot.h

@@ -1,13 +1,11 @@
 #ifndef ROPE_H
 #define ROPE_H
 
-#include "./pch.h"
-#include "./utils.h"
+#include "pch.h"
+#include "utils/utils.h"
 
 #define MIN_CHUNK_SIZE 64       // 64 Bytes
 #define MAX_CHUNK_SIZE 1024 * 8 // 8192 Bytes (8 KiB)
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
 #define DEPTH(n) ((n) ? (n)->depth : 0)
 
 // Rope node definition

include/io/ui.h

@@ -1,8 +1,8 @@
 #ifndef UI_H
 #define UI_H
 
-#include "./pch.h"
-#include "./utils.h"
+#include "pch.h"
+#include "utils/utils.h"
 
 #define KEY_CHAR 0
 #define KEY_SPECIAL 1

include/lsp/lsp.h

@@ -1,9 +1,9 @@
 #ifndef LSP_H
 #define LSP_H
 
-#include "./editor.h"
-#include "./pch.h"
-#include "utils.h"
+#include "editor/editor.h"
+#include "pch.h"
+#include "utils/utils.h"
 
 struct LSP {
   const char *command;
@@ -45,20 +45,37 @@ struct LSPInstance {
 
 extern std::shared_mutex active_lsps_mtx;
 extern std::unordered_map<uint8_t, std::shared_ptr<LSPInstance>> active_lsps;
+extern Queue<LSPOpenRequest> lsp_open_queue;
 
-void lsp_worker();
-void lsp_handle(std::shared_ptr<LSPInstance> lsp, json message);
-
-std::shared_ptr<LSPInstance> get_or_init_lsp(uint8_t lsp_id);
-void close_lsp(uint8_t lsp_id);
-
-void request_add_to_lsp(Language language, Editor *editor);
-void open_editor(std::shared_ptr<LSPInstance> lsp,
-                 std::pair<Language, Editor *> entry);
-void add_to_lsp(Language language, Editor *editor);
-void remove_from_lsp(Editor *editor);
+static json client_capabilities = {
+    {"textDocument",
+     {{"publishDiagnostics", {{"relatedInformation", true}}},
+      {"hover", {{"contentFormat", {"markdown", "plaintext"}}}},
+      {"completion",
+       {{"completionItem",
+         {{"snippetSupport", true},
+          {"documentationFormat", {"markdown", "plaintext"}},
+          {"resolveSupport", {{"properties", {"documentation", "detail"}}}},
+          {"insertReplaceSupport", true},
+          {"labelDetailsSupport", true},
+          {"insertTextModeSupport", {{"valueSet", {1}}}}}},
+        {"completionItemKind", {{"valueSet", {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}}},
+        {"contextSupport", true},
+        {"insertTextMode", 1}}}}}};
 
 void lsp_send(std::shared_ptr<LSPInstance> lsp, json message,
               LSPPending *pending);
+void lsp_worker();
+
+std::shared_ptr<LSPInstance> get_or_init_lsp(uint8_t lsp_id);
+void clean_lsp(std::shared_ptr<LSPInstance> lsp, uint8_t lsp_id);
+void close_lsp(uint8_t lsp_id);
+
+void open_editor(std::shared_ptr<LSPInstance> lsp,
+                 std::pair<Language, Editor *> entry);
+void request_add_to_lsp(Language language, Editor *editor);
+void add_to_lsp(Language language, Editor *editor);
+void remove_from_lsp(Editor *editor);
+void lsp_handle(std::shared_ptr<LSPInstance> lsp, json message);
 
 #endif

include/main.h

@@ -1,7 +1,7 @@
 #ifndef MAIN_H
 #define MAIN_H
 
-#include "./pch.h"
+#include "pch.h"
 
 #define NORMAL 0
 #define INSERT 1

include/pch.h

@@ -4,17 +4,23 @@
 #define PCRE2_CODE_UNIT_WIDTH 8
 #define PCRE_WORKSPACE_SIZE 512
 
-#include "../libs/tree-sitter/lib/include/tree_sitter/api.h"
+extern "C" {
+#include "libgrapheme/grapheme.h"
+#include "unicode_width/unicode_width.h"
+}
+#include "tree-sitter/lib/include/tree_sitter/api.h"
 #include <algorithm>
 #include <atomic>
 #include <cctype>
 #include <chrono>
+#include <cmath>
 #include <cstdarg>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <deque>
+#include <fcntl.h>
 #include <filesystem>
 #include <fstream>
 #include <functional>
@@ -27,9 +33,13 @@
 #include <pcre2.h>
 #include <queue>
 #include <shared_mutex>
+#include <signal.h>
 #include <string.h>
 #include <string>
 #include <sys/ioctl.h>
+#include <sys/poll.h>
+#include <sys/types.h>
+#include <sys/wait.h>
 #include <termios.h>
 #include <thread>
 #include <unistd.h>

include/ts/decl.h

@@ -1,7 +1,7 @@
-#ifndef TS_DEF_H
-#define TS_DEF_H
+#ifndef TS_DECL_H
+#define TS_DECL_H
 
-#include "./pch.h"
+#include "pch.h"
 
 #define LANG(name) tree_sitter_##name
 #define TS_DEF(name) extern "C" const TSLanguage *LANG(name)()

include/ts/ts.h

@@ -1,9 +1,9 @@
 #ifndef TS_H
 #define TS_H
 
-#include "./editor.h"
-#include "./pch.h"
-#include "./utils.h"
+#include "editor/editor.h"
+#include "pch.h"
+#include "utils/utils.h"
 
 #define HEX(s) (static_cast<uint32_t>(std::stoul(s, nullptr, 16)))
 
@@ -14,12 +14,5 @@ void ts_collect_spans(Editor *editor);
 bool ts_predicate(TSQuery *query, const TSQueryMatch &match,
                   std::function<std::string(const TSNode *)> subject_fn);
 void clear_regex_cache();
-template <typename T>
-inline T *safe_get(std::map<uint16_t, T> &m, uint16_t key) {
-  auto it = m.find(key);
-  if (it == m.end())
-    return nullptr;
-  return &it->second;
-}
 
 #endif

include/utils/utils.h

@@ -1,8 +1,8 @@
 #ifndef UTILS_H
 #define UTILS_H
 
-#include "./pch.h"
-#include "./ts_def.h"
+#include "pch.h"
+#include "ts/decl.h"
 
 template <typename T> struct Queue {
   std::queue<T> q;
@@ -59,28 +59,41 @@ struct Match {
   std::string text;
 };
 
-std::vector<Match> find_all_matches(const std::string &subject,
-                                    const std::string &pattern);
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+
 std::string clean_text(const std::string &input);
 std::string percent_encode(const std::string &s);
 std::string percent_decode(const std::string &s);
-std::string path_abs(const std::string &path_str);
-std::string path_to_file_uri(const std::string &path_str);
+uint32_t count_clusters(const char *line, size_t len, size_t from, size_t to);
+std::string trim(const std::string &s);
+
 int display_width(const char *str, size_t len);
 uint32_t get_visual_col_from_bytes(const char *line, uint32_t len,
                                    uint32_t byte_limit);
 uint32_t get_bytes_from_visual_col(const char *line, uint32_t len,
                                    uint32_t target_visual_col);
+int utf8_byte_offset_to_utf16(const char *s, size_t byte_pos);
+
 void log(const char *fmt, ...);
+
+std::string path_abs(const std::string &path_str);
+std::string path_to_file_uri(const std::string &path_str);
 std::string get_exe_dir();
 char *load_file(const char *path, uint32_t *out_len);
 char *detect_file_type(const char *filename);
-int utf8_byte_offset_to_utf16(const char *s, size_t byte_pos);
 Language language_for_file(const char *filename);
+
 void copy_to_clipboard(const char *text, size_t len);
 char *get_from_clipboard(uint32_t *out_len);
-uint32_t count_clusters(const char *line, size_t len, size_t from, size_t to);
-std::string trim(const std::string &s);
+
+template <typename T>
+inline T *safe_get(std::map<uint16_t, T> &m, uint16_t key) {
+  auto it = m.find(key);
+  if (it == m.end())
+    return nullptr;
+  return &it->second;
+}
 
 template <typename Func, typename... Args>
 auto throttle(std::chrono::milliseconds min_duration, Func &&func,