Updated docs, cleanup

Author: Nimaoth

README.md

@@ -53,6 +53,7 @@ Download latest [release](https://github.com/Nimaoth/Nev/releases) or [build fro
 - [Getting started](docs/getting_started.md)
 - [Cheatsheet](docs/cheatsheet.md)
 - [Configuration](docs/configuration.md)
+- [Keybindings](docs/keybindings.md)
 - [Finders](docs/finders.md)
 - [Plugin API](https://nimaoth.github.io/AbsytreeDocs/scripting_nim/htmldocs/theindex.html).
 - [Virtual filesystem](docs/virtual_file_system.md)

config/keybindings.json

@@ -299,33 +299,33 @@
     },
 
     "vim#text_object": {
-        "<?-count>iw": ["vim-select-text-object", "vim-word-inner", false, true, "<#move.count>"],
-        "<?-count>aw": ["vim-select-text-object", "vim-word-outer", false, true, "<#move.count>"],
-        "<?-count>iW": ["vim-select-text-object", "vim-WORD-inner", false, true, "<#move.count>"],
-        "<?-count>aW": ["vim-select-text-object", "vim-WORD-outer", false, true, "<#move.count>"],
-        "<?-count>ip": ["vim-select-text-object", "vim-paragraph-inner", false, true, "<#move.count>"],
-        "<?-count>ap": ["vim-select-text-object", "vim-paragraph-outer", false, true, "<#move.count>"],
-
-        "<?-count>i{": ["vim-select-surrounding", "vim-surround-{-inner", false, true, "<#move.count>"],
-        "<?-count>a{": ["vim-select-surrounding", "vim-surround-{-outer", false, true, "<#move.count>"],
-        "<?-count>i}": ["vim-select-surrounding", "vim-surround-{-inner", false, true, "<#move.count>"],
-        "<?-count>a}": ["vim-select-surrounding", "vim-surround-{-outer", false, true, "<#move.count>"],
-        "<?-count>i(": ["vim-select-surrounding", "vim-surround-(-inner", false, true, "<#move.count>"],
-        "<?-count>a(": ["vim-select-surrounding", "vim-surround-(-outer", false, true, "<#move.count>"],
-        "<?-count>i)": ["vim-select-surrounding", "vim-surround-(-inner", false, true, "<#move.count>"],
-        "<?-count>a)": ["vim-select-surrounding", "vim-surround-(-outer", false, true, "<#move.count>"],
-        "<?-count>i[": ["vim-select-surrounding", "vim-surround-[-inner", false, true, "<#move.count>"],
-        "<?-count>a[": ["vim-select-surrounding", "vim-surround-[-outer", false, true, "<#move.count>"],
-        "<?-count>i]": ["vim-select-surrounding", "vim-surround-[-inner", false, true, "<#move.count>"],
-        "<?-count>a]": ["vim-select-surrounding", "vim-surround-[-outer", false, true, "<#move.count>"],
-        "<?-count>i\\<": ["vim-select-surrounding", "vim-surround-angle-inner", false, true, "<#move.count>"],
-        "<?-count>a\\<": ["vim-select-surrounding", "vim-surround-angle-outer", false, true, "<#move.count>"],
-        "<?-count>i\\>": ["vim-select-surrounding", "vim-surround-angle-inner", false, true, "<#move.count>"],
-        "<?-count>a\\>": ["vim-select-surrounding", "vim-surround-angle-outer", false, true, "<#move.count>"],
-        "<?-count>i\"": ["vim-select-surrounding", "vim-surround-\"-inner", false, true, "<#move.count>"],
-        "<?-count>a\"": ["vim-select-surrounding", "vim-surround-\"-outer", false, true, "<#move.count>"],
-        "<?-count>i'": ["vim-select-surrounding", "vim-surround-'-inner", false, true, "<#move.count>"],
-        "<?-count>a'": ["vim-select-surrounding", "vim-surround-'-outer", false, true, "<#move.count>"],
+        "<?-count>iw": ["vim-select-text-object", "vim-word-inner", false, true, "<#text_object.count>"],
+        "<?-count>aw": ["vim-select-text-object", "vim-word-outer", false, true, "<#text_object.count>"],
+        "<?-count>iW": ["vim-select-text-object", "vim-WORD-inner", false, true, "<#text_object.count>"],
+        "<?-count>aW": ["vim-select-text-object", "vim-WORD-outer", false, true, "<#text_object.count>"],
+        "<?-count>ip": ["vim-select-text-object", "vim-paragraph-inner", false, true, "<#text_object.count>"],
+        "<?-count>ap": ["vim-select-text-object", "vim-paragraph-outer", false, true, "<#text_object.count>"],
+
+        "<?-count>i{": ["vim-select-surrounding", "vim-surround-{-inner", false, true, "<#text_object.count>"],
+        "<?-count>a{": ["vim-select-surrounding", "vim-surround-{-outer", false, true, "<#text_object.count>"],
+        "<?-count>i}": ["vim-select-surrounding", "vim-surround-{-inner", false, true, "<#text_object.count>"],
+        "<?-count>a}": ["vim-select-surrounding", "vim-surround-{-outer", false, true, "<#text_object.count>"],
+        "<?-count>i(": ["vim-select-surrounding", "vim-surround-(-inner", false, true, "<#text_object.count>"],
+        "<?-count>a(": ["vim-select-surrounding", "vim-surround-(-outer", false, true, "<#text_object.count>"],
+        "<?-count>i)": ["vim-select-surrounding", "vim-surround-(-inner", false, true, "<#text_object.count>"],
+        "<?-count>a)": ["vim-select-surrounding", "vim-surround-(-outer", false, true, "<#text_object.count>"],
+        "<?-count>i[": ["vim-select-surrounding", "vim-surround-[-inner", false, true, "<#text_object.count>"],
+        "<?-count>a[": ["vim-select-surrounding", "vim-surround-[-outer", false, true, "<#text_object.count>"],
+        "<?-count>i]": ["vim-select-surrounding", "vim-surround-[-inner", false, true, "<#text_object.count>"],
+        "<?-count>a]": ["vim-select-surrounding", "vim-surround-[-outer", false, true, "<#text_object.count>"],
+        "<?-count>i\\<": ["vim-select-surrounding", "vim-surround-angle-inner", false, true, "<#text_object.count>"],
+        "<?-count>a\\<": ["vim-select-surrounding", "vim-surround-angle-outer", false, true, "<#text_object.count>"],
+        "<?-count>i\\>": ["vim-select-surrounding", "vim-surround-angle-inner", false, true, "<#text_object.count>"],
+        "<?-count>a\\>": ["vim-select-surrounding", "vim-surround-angle-outer", false, true, "<#text_object.count>"],
+        "<?-count>i\"": ["vim-select-surrounding", "vim-surround-\"-inner", false, true, "<#text_object.count>"],
+        "<?-count>a\"": ["vim-select-surrounding", "vim-surround-\"-outer", false, true, "<#text_object.count>"],
+        "<?-count>i'": ["vim-select-surrounding", "vim-surround-'-inner", false, true, "<#text_object.count>"],
+        "<?-count>a'": ["vim-select-surrounding", "vim-surround-'-outer", false, true, "<#text_object.count>"],
     },
 
     "vim#move": {
@@ -658,7 +658,12 @@
         "<SPACE>": ["all", [".vim-paste", false, true, "vim-default-register"], [".set-mode", "vim.insert"]],
     },
 
-
+    "vim.completion": {
+        "<C-p>": ["select-prev-completion"],
+        "<C-n>": ["select-next-completion"],
+        "<C-y>": ["apply-selected-completion"],
+        "<TAB>": ["apply-selected-completion"],
+    },
 
     // vscode
     "vscode.base": {

config/settings-vim.json

@@ -9,6 +9,7 @@
     // "selector.base-mode": "vim.selector",
     "text.modes": ["vim", "vim.normal"],
     "text.default-mode": "vim.normal",
+    "text.completion-mode": "vim.completion",
 
     "lang.command-line.text.modes": ["vim", "vim.insert"],
     "lang.command-line.text.default-mode": "vim.insert",

config/settings-vscode.json

@@ -6,6 +6,9 @@
     "editor.command-line-result-mode-low": "vscode.command-line-result-low",
     "terminal.base-mode": "vscode.terminal",
     "selector.base-mode": "vscode.selector",
+    "text.modes": ["vscode"],
+    "text.default-mode": "vscode",
+    "text.completion-mode": "vscode.completion",
 
     "input": {
         "vscode.handle-inputs": true,
@@ -19,9 +22,6 @@
         "vscode.terminal.handle-keys": true,
     },
 
-    "text.completion-mode": "vscode.completion",
-    "text.modes": ["vscode"],
-    "text.default-mode": "vscode",
     "text.inclusive-selection": false,
 
     "editor.text.cursor.movement.": "both",

docs/configuration.md

@@ -235,156 +235,6 @@ setOption "editor.text.triple-click-command-args", %[%"vim-paragraph-inner", %tr
 # and "double-click-command"/"double-click-command-args"
 ```
 
-# Key bindings
-You can bind different key combinations to __commands__. Each function exposed by the editor (see `plugin_api.nim`) has a corresponding command,
-which has two names. If the function is called `myCommand`, then the command can be executed using either `myCommand` or `my-command`.
-
-Key combinations are bound to a command and arguments for that command. The following binds the command `quit` to the key combination `CTRL-x + x`
-
-```nim
-addCommand "editor", "<C-x>x", "quit"
-```
-
-Key combinations can be as long as you want, and contain any combination of modifiers, as long as the OS supports that combination.
-Most keys can be specified using their ASCII value, i.e. to bind to e.g. the `k` key you would use `addCommand "editor", "k", "command-name"`.
-Special keys like the space bar are specified using < and >: `addCommand "editor", "<SPACE>", "command-name"`.
-The following special keys are defined:
-- ENTER
-- ESCAPE
-- BACKSPACE
-- SPACE
-- DELETE
-- TAB
-- LEFT
-- RIGHT
-- UP
-- DOWN
-- HOME
-- END
-- PAGE_UP
-- PAGE_DOWN
-- F1, ..., F12
-
-To specify that a modifier should be held down together with another key you need to used `<XXX-YYY>`, where `XXX` is any combination of modifiers
-(`S` = shift, `C` = control, `A` = alt) and `YYY` is either a single ASCII character for the key, or one of the special keys (e.g. `ENTER`).
-
-If you use an upper case ASCII character as key then this automatically means it uses shift, so `A` is equivalent to `<S-a>` and `<S-A>`
-
-Some examples:
-
-```nim
-addCommand "editor", "a", "command-name"
-addCommand "editor", "<C-a>", "command-name" # CTRL+a
-addCommand "editor", "<CS-a>", "command-name" # CTRL+SHIFT+a
-addCommand "editor", "<CS-SPACE>", "command-name" # CTRL+SHIFT+SPACE
-addCommand "editor", "SPACE<C-g>", "command-name" # SPACE, followed by CTRL+g
-```
-
-Be careful not to do bind multiple keys where one is a prefix of another in the same mode:
-
-```nim
-addCommand "editor", "a", "command-name"
-addCommand "editor", "aa", "command-name" # Will never be used, because pressing a once will immediately execute the first binding
-```
-
-You can define multi key keybindings with keys which produce characters (like `w`) in modes that consume input (like insert mode) while still being able to insert the original key by waiting or pressing another key which is not in the bound sequence.
-- Example: when you bind `jj` in insert mode to exit to normal mode, three things can happen:
-  - You press `j` once then after a configured delay the `j` will be inserted as text
-  - You press `j` twice in a row, faster than the configured delay, then it will exit to normal mode
-  - You press `j` once followed by another key (e.g `k`) faster than the configured delay. `j` will be inserted and
-    the next key press will be handled as usual.
-
-The delay is configured using `editor.insert-input-delay`.
-
-## Repeat keys within longer keybindings
-
-There is one special modifier `*` which means the following keys can be repeated without having to press the first keys again:
-
-```nim
-# after pressing "<C-w>F", you can press "+" or "-" multiple times, and the input state machine resets to the <*-F> state instead of
-# to the beginning
-addCommand "editor", "<C-w><*-F>-", "change-font-size", -1
-addCommand "editor", "<C-w><*-F>+", "change-font-size", 1
-```
-
-All keybindings in the same scope (e.g. `editor`) will be compiled into a state machine. When you press a key, the state machine will advance,
-and if it reaches and end state it will execute the command stored in the state (with the arguments also stored in the state).
-Each `addCommand` corresponds to one end state.
-
-# Scopes/Context
-The first parameter to `addCommand` is a scope. Different scopes can have different keybindings, even conflicting ones.
-Depending on which scopes are active the corresponding commands will be executed.
-Which scopes are active depends on which editor view is selected, whether there is e.g. an auto completion window open.
-The scope stack looks like this
-At the bottom of the scope stack is always `editor`.
-- `editor`
-- `editor.<MODE>`, if the editor mode is not `""` and `editor.custom-mode-on-top` is false. `<MODE>` is the current editor mode.
-- One of the following:
-  - `commandLine`, if the editor is in command line mode
-
-  - If there is a popup open, then the following scopes:
-    - If the popup is a selector popup, then the following scopes:
-      - Same as a text editor (i.e. `editor.text`, etc)
-      - `popup.selector`, always
-
-  - If the selected view contains a text document, then the following scopes:
-    - `editor.text`, always
-    - `editor.text.<MODE>`, if the text editor mode is not `""`
-    - `editor.text.completion`, if the text editor has a completion window open.
-
-  - If the selected view contains a model document, then the following scopes:
-    - `editor.model`, always
-    - `editor.model.<MODE>`, if the model editor mode is not `""`
-
-- `editor.<MODE>`, if the editor mode is not `""` and `editor.custom-mode-on-top` is true. `<MODE>` is the current editor mode.
-
-So if you for example have text editor selected and a completion window is open, and the text editor is in `insert` mode, the scope stack would look like this:
-
-- `editor` (bottom, handled by Editor)
-- `editor.text` (handled by TextEditor)
-- `editor.text.insert` (handled by TextEditor)
-- `editor.text.completion` (top, handled by TextEditor)
-
-If you have no completion window open and no mode selected then it would look like this:
-
-- `editor` (bottom, handled by Editor)
-- `editor.text` (top, handled by TextEditor)
-
-When a key is pressed, the editor will advance the state machine for every scope in the stack, from top to bottom (i.e. the `editor` scope will always be last).
-The first scope which reaches an end state will execute its' command, which will be handled by the owner of the scope. Then all state machines in the stack are reset.
-The owners of the scopes are the following:
-- `Editor`: `editor`, `commandLine`, `editor.<MODE>`
-- `TextEditor`: `editor.text`, `editor.text.<MODE>`, `editor.text.completion`
-- `ModelEditor`: `editor.model`, `editor.model.<MODE>`, `editor.model.completion`
-- `SelectorPopup`: `popup.selector`
-
-# Summary
-To define keybindings specific for text documents (TextEditor), use:
-
-```nim
-addCommand "editor.text", "a", "command-name"
-addTextCommand "", "a", "command-name"                  # Same as above
-
-addCommand "editor.text.insert", "a", "command-name"    # Insert mode
-addTextCommand "insert", "a", "command-name"            # Same as above
-
-addTextCommand "completion", "a", "command-name"        # Only active while completion window is open
-
-addTextCommandBlock "", "s":                            # First parameter is mode/"completion"
-  ## Creates an anonymous action which runs this block. `editor` (automatically defined) is the text editor handling this command
-  editor.setMode("insert")
-  editor.selections = editor.delete(editor.selections)
-
-addTextCommand "", "a", proc(editor: TextDocumentEditor) =
-  ## Creates an anonymous action which runs this lambda. `editor` is the text editor handling this command.
-  # ...
-
-proc foo(editor: TextDocumentEditor) =
-  # ...
-
-addTextCommand "", "a", foo                                 # Like above, but uses existing function
-```
-
 # Scripting API Documentation
 The documentation for the scripting API is in scripting/htmldocs. You can see the current version [here](https://raw.githack.com/Nimaoth/AbsytreeDocs/main/scripting_nim/htmldocs/theindex.html) (using raw.githack.com) or [here](https://nimaoth.github.io/AbsytreeDocs/scripting_nim/htmldocs/theindex.html).