SyedM/crib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 5 Wiki Activity

Move folder

Browse Source
This commit is contained in:
Syed Daanish
2026-04-13 10:32:46 +01:00
parent c683754d49
commit 037f884050
107 changed files with 292 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
TODO.md Normal file → Executable file
View File

@@ -2,35 +2,45 @@ Copyright 2025 Syed Daanish
# TODO
## Next few super long boring things to do::
* redo lsp threads such that no mutex needed for any rope stuff (done)
- Also make the classes own the methods in lsp (done)
- This will mean that parsers/renderers and keystrokes will not need to be individually locked (done)
- And so it will be much faster (done)
- At which point the main thread can also be blocked on user input or lsp responses and still be faster
* Add a superclass for editor called Window (which can be popup or tiled) (done)
* Add a recursive tiling class for windows (done)
* Handled by a single renderer that calls and renders each window (done)
* Make editor's functions into its own methods (classify it) (done)
- While at it
- Seperate system functions into a class that branches to support local / ssh / server modes.
- Even lsp shouldnt be directly controlled because it can branch on local and server modes
- check wolfSSH stuff for remote editing
- Thick and thin mode
- thin mode only shares screen diffing over the network - uses server settings / themes
- thick only shared fileio and lsp data with local used for all else - uses local settings / themes
- Redo hooks as a engine of its own.
- And factorize renderer into its own class (and make it just return an array of the render without knowing teh x,y)
- which is just managed by the renderer
- which is reused by scrollers/ensurers too
- this will then allow inlay hints to be possible
- and also make VAI easier to implement
- And factorize renderer into its own class
- which is just managed by the renderer
- and adjusment.cc will call it
- which is reused by scrollers/ensurers too (for knowing screen wrapped end)
- this will then allow inlay hints to be possible
- and also make VAI easier to implement
* Allow keybinds to be set in ruby
* then the fun part:
* ruby file for project specific runs alongside any system wide ones
- Seperate system functions into a class that branches to support local / ssh / server modes.
- Even lsp shouldnt be directly controlled because it can branch on local and server modes
- check libssh2 or child process stuff for remote editing (remote mode)
- Thick and thin mode (server mode) (through ssh or port) (for website only port + webhook)
- thin mode only shares screen diffing over the network - uses server settings / themes / shell
- only one user connects at a time
- provides data as a websocket with tui or gui/online modes where tui shares diffing as is (can be connected to by gui or website)
- and gui/online modes try to (if not then render onto a canvas) forward window.render_gui() and dedicated windowing system (i.e windowing is html divs)
- and window.render_gui() returns a markup code (custom markup)
- and for events i could either leave tui as-is and for markup have special event handling or i
- implement the widget system in both and have the same event handling then
- actually for true cross platform i need to make a ui lib with widgets etc. so it is workable on all platforms (so they all need only a single ui lib)
- thick only shared fileio and lsp data with local used for all else - uses local settings / themes
- multiple users connect at once but maybe either make them not be allowed to open same file or make vscode like multiediting (unsure how exactly)
- they all share same lsp instances
- they all have the same shell access
- allow having an instance that forwards thick mode to thin mode (to connect online mode to a thick server for code collaboration)
* Then allow ruby code to create and handle windows as extentions
* Then 3 inbuilt extentions being file manager, theme picker, tab selector
* make another tile type called tile tabbed that has a tab switcher and shows only one of its children at once
* it takes focus and takes some keybinds for switching and forwards the rest (it also forwards the info and adds one for itself - the selected/total tabs)
* also implement info strings for all the stuff that take focus
* Mode is a feild on a editor and there is no global "mode system" except in editors (enxtentions do their own thing)
* make mode normal and not atomic if it is truly unused across threads
* this means keybinds can be set to use the editor as insert mode only and so behave like vscode
* split lsp stuff into multiple files (not a monolithic class as it is now)
* Extentions can also be used as file openers (for like databases . diffing . images . audio etc)
* Local cache for state management (like undo history, cursor positions etc) (location can be set in config)
* make sure to write inbuilt extentions in cpp and not ruby
@@ -110,8 +120,6 @@ Copyright 2025 Syed Daanish
* [ ] **Auto brace selection:** Add support for auto brace selection.
* [ ] **Tree-sitter Indent:** Attempt to allow Tree-sitter to handle indentation if possible.
### UX
* [ ] **Completion Filtering:**
@@ -120,7 +128,7 @@ Copyright 2025 Syed Daanish
* [ ] **Basic Autocomplete:** Keep a list of words in the current buffer for non-LSP fallback.
### Major Features
### Features
* [ ] **Search & Replace:**
* [ ] Add Search/Replace UI.
@@ -154,3 +162,14 @@ Copyright 2025 Syed Daanish
* [ ] Switch JSON parser to `RapidJSON` (or similar high-performance lib).
* [ ] Decrease usage of `std::string` in UI, LSP, warnings etc.
* [ ] Also for vectors into managed memory especially for completions/lsp-stuff.
<!-- The pits of hell: -->
<!-- * Replace perfectly working superfast rope with a structure that stores for small files everything -->
<!-- - but for large ones it stores only what the user viewed / edited (by line number) -->
<!-- - the rest is from the disk and not entirely loaded into memory (keep as option maybe they want everything in memory?) -->
<!-- - also for the line mode still go through entire file to get and store line offsets -->
<!-- - also it stores everything prolly still as rope tho (rope of lines) (or sparse map) -->
<!-- - it stores the line text as-is which is only unicode / crlf normalized during usage -->