fix(input/#382): Leader-key customization (#2672)

This adds support for specifying the `<leader>` key in `keybindings.json` as well as mappings coming from VimL (`map` family).

The leader key can be specified via either:
- `vim.leader` configuration setting in `configuration.json` - ie: `"vim.leader": "<space>"`
- `:map <space> <leader>`"` via an Ex command.

In addition, this also lays some groundwork for some other binding constructs we need... Like support for handling `<Plug>` and `<SNR>` as part of the VimL integration work.

__TODO:__ 
- [x] Depends on #2668 
- [x] Add `vim.leader` configuration setting
- [x] Update documentation

__Next steps:__
- Pull leader key from `let mapleader`, if available - this requires a bit of extra work in libvim: onivim/libvim#244

Author: bryphe

docs/docs/configuration/key-bindings.md

@@ -223,3 +223,31 @@ Examples:
   {"key": "kk", "command": ":split", "when": "editorTextFocus"},
   {"key": "<C-D>", "command": ":d 2", "when": "insertMode"}
 ```
+
+### Leader Key
+
+A leader key can be specified via the following configuration setting:
+
+```
+{ "vim.leader": "<space>" }
+```
+> NOTE: This setting is in `configuration.json`, not `keybindings.json`
+
+Alternatively, the leader key can be specified via an `Ex` command:
+```
+:nmap <space> <Leader>
+```
+
+Once the leader key is defined, it may be used in both `keybindings.json` and via VimL map commands:
+
+```
+[
+  { "key": "<Leader>p", "command": "workbench.action.quickOpen", "when": "editorTextFocus && normalMode" }
+]
+```
+
+or, alternatively, in VimL:
+
+```
+:nnoremap <Leader>p <C-S-P>
+```

docs/docs/configuration/settings.md

@@ -98,6 +98,10 @@ The configuration file, `configuration.json` is in the Oni2 directory, whose loc
 
 - `vim.highlightedyank.duration` __(_int_ default: `300`)__ - The time, in milliseconds, the yank highlight is visible.
 
+### Input
+
+- `vim.leader` __(_string_)__ - Specify a custom [leader key](./key-bindings#leader-key). 
+
 ### Layout
 
 - `workbench.editor.showTabs` __(_bool_ default: `true`)__ - When `false`, hides the editor tabs.

integration_test/ExCommandKeybindingTest.re

@@ -17,11 +17,11 @@ runTest(
   (dispatch, wait, _) => {
     let input = key => {
       let keyPress =
-        EditorInput.KeyPress.{
-          scancode: Sdl2.Scancode.ofName(key),
-          keycode: Sdl2.Keycode.ofName(key),
-          modifiers: EditorInput.Modifiers.none,
-        };
+        EditorInput.KeyPress.physicalKey(
+          ~scancode=Sdl2.Scancode.ofName(key),
+          ~keycode=Sdl2.Keycode.ofName(key),
+          ~modifiers=EditorInput.Modifiers.none,
+        );
       let time = Revery.Time.now();
 
       dispatch(KeyDown(keyPress, time));

integration_test/ExCommandKeybindingWithArgsTest.re

@@ -18,11 +18,11 @@ runTest(
   (dispatch, wait, _) => {
     let input = key => {
       let keyPress =
-        EditorInput.KeyPress.{
-          scancode: Sdl2.Scancode.ofName(key),
-          keycode: Sdl2.Keycode.ofName(key),
-          modifiers: EditorInput.Modifiers.none,
-        };
+        EditorInput.KeyPress.physicalKey(
+          ~scancode=Sdl2.Scancode.ofName(key),
+          ~keycode=Sdl2.Keycode.ofName(key),
+          ~modifiers=EditorInput.Modifiers.none,
+        );
       let time = Revery.Time.now();
 
       dispatch(KeyDown(keyPress, time));

integration_test/KeySequenceJJTest.re

@@ -21,7 +21,8 @@ runTest(
       let keycode = Sdl2.Keycode.ofName(key);
       let modifiers = EditorInput.Modifiers.none;
 
-      let keyPress: EditorInput.KeyPress.t = {scancode, keycode, modifiers};
+      let keyPress: EditorInput.KeyPress.t =
+        EditorInput.KeyPress.physicalKey(~keycode, ~scancode, ~modifiers);
       let time = Revery.Time.now();
 
       dispatch(Model.Actions.KeyDown(keyPress, time));

integration_test/VimSimpleRemapTest.re

@@ -15,7 +15,8 @@ runTest(~name="VimSimpleRemapTest", (dispatch, wait, runEffects) => {
     let keycode = Sdl2.Keycode.ofName(key);
     let modifiers = EditorInput.Modifiers.none;
 
-    let keyPress: EditorInput.KeyPress.t = {scancode, keycode, modifiers};
+    let keyPress: EditorInput.KeyPress.t =
+      EditorInput.KeyPress.physicalKey(~scancode, ~keycode, ~modifiers);
     let time = Revery.Time.now();
 
     dispatch(Model.Actions.KeyDown(keyPress, time));

src/Core/Config.re

@@ -13,6 +13,8 @@ type key = Lookup.path;
 type resolver = (~vimSetting: option(string), key) => rawValue;
 type fileTypeResolver = (~fileType: string) => resolver;
 
+let emptyResolver = (~vimSetting as _, _) => NotSet;
+
 let key = Lookup.path;
 let keyAsString = Lookup.key;
 

src/Core/Config.rei

@@ -9,6 +9,8 @@ type rawValue =
 type resolver = (~vimSetting: option(string), key) => rawValue;
 type fileTypeResolver = (~fileType: string) => resolver;
 
+let emptyResolver: resolver;
+
 let key: string => key;
 let keyAsString: key => string;
 

src/Feature/Input/Feature_Input.re

@@ -4,6 +4,67 @@ open Oni_Core;
 open Utility;
 module Log = (val Log.withNamespace("Oni2.Feature.Input"));
 
+// CONFIGURATION
+module Configuration = {
+  open Oni_Core;
+  open Config.Schema;
+
+  module CustomDecoders = {
+    let physicalKey =
+      custom(
+        ~decode=
+          Json.Decode.(
+            string
+            |> and_then(keyString =>
+                 if (keyString == "(none)") {
+                   succeed(None);
+                 } else {
+                   switch (
+                     EditorInput.KeyPress.parse(
+                       ~getKeycode,
+                       ~getScancode,
+                       keyString,
+                     )
+                   ) {
+                   | Ok([]) =>
+                     fail("Unable to parse key sequence: " ++ keyString)
+                   | Ok([key]) =>
+                     switch (EditorInput.KeyPress.toPhysicalKey(key)) {
+                     | None => fail("Not a physical key: " ++ keyString)
+                     | Some(physicalKey) => succeed(Some(physicalKey))
+                     }
+                   | Ok(_keys) =>
+                     fail(
+                       "Unable to parse key sequence - too many keys: "
+                       ++ keyString,
+                     )
+                   | Error(msg) =>
+                     fail("Unable to parse key sequence: " ++ msg)
+                   };
+                 }
+               )
+          ),
+        ~encode=
+          Json.Encode.(
+            maybeKey => {
+              switch (maybeKey) {
+              | Some(key) =>
+                EditorInput.KeyPress.toString(
+                  ~keyCodeToString=Sdl2.Keycode.getName,
+                  EditorInput.KeyPress.PhysicalKey(key),
+                )
+                |> string
+              | None => "(none)" |> string
+              };
+            }
+          ),
+      );
+  };
+
+  let leaderKey =
+    setting("vim.leader", CustomDecoders.physicalKey, ~default=None);
+};
+
 // MSG
 
 type outmsg =
@@ -73,6 +134,8 @@ type model = {
   inputStateMachine: InputStateMachine.t,
 };
 
+type uniqueId = InputStateMachine.uniqueId;
+
 let initial = keybindings => {
   open Schema;
   let inputStateMachine =
@@ -107,9 +170,10 @@ type effect =
     | Unhandled(EditorInput.KeyPress.t)
     | RemapRecursionLimitHit;
 
-let keyDown = (~key, ~context, {inputStateMachine, _} as model) => {
+let keyDown = (~config, ~key, ~context, {inputStateMachine, _} as model) => {
+  let leaderKey = Configuration.leaderKey.get(config);
   let (inputStateMachine', effects) =
-    InputStateMachine.keyDown(~key, ~context, inputStateMachine);
+    InputStateMachine.keyDown(~leaderKey, ~key, ~context, inputStateMachine);
   ({...model, inputStateMachine: inputStateMachine'}, effects);
 };
 
@@ -119,12 +183,31 @@ let text = (~text, {inputStateMachine, _} as model) => {
   ({...model, inputStateMachine: inputStateMachine'}, effects);
 };
 
-let keyUp = (~key, ~context, {inputStateMachine, _} as model) => {
+let keyUp = (~config, ~key, ~context, {inputStateMachine, _} as model) => {
+  let leaderKey = Configuration.leaderKey.get(config);
   let (inputStateMachine', effects) =
-    InputStateMachine.keyUp(~key, ~context, inputStateMachine);
+    InputStateMachine.keyUp(~leaderKey, ~key, ~context, inputStateMachine);
   ({...model, inputStateMachine: inputStateMachine'}, effects);
 };
 
+let addKeyBinding = (~binding, {inputStateMachine, _} as model) => {
+  open Schema;
+  let (inputStateMachine', uniqueId) =
+    InputStateMachine.addBinding(
+      binding.matcher,
+      binding.condition,
+      binding.command,
+      inputStateMachine,
+    );
+  ({...model, inputStateMachine: inputStateMachine'}, uniqueId);
+};
+
+let remove = (uniqueId, {inputStateMachine, _} as model) => {
+  let inputStateMachine' =
+    InputStateMachine.remove(uniqueId, inputStateMachine);
+  {...model, inputStateMachine: inputStateMachine'};
+};
+
 // UPDATE
 module Internal = {
   let vimMapModeToWhenExpr = mode => {
@@ -253,4 +336,5 @@ module Commands = {
 
 module Contributions = {
   let commands = Commands.[showInputState];
+  let configuration = Configuration.[leaderKey.spec];
 };

src/Feature/Input/Feature_Input.rei

@@ -47,16 +47,36 @@ type effect =
   | RemapRecursionLimitHit;
 
 let keyDown:
-  (~key: KeyPress.t, ~context: WhenExpr.ContextKeys.t, model) =>
+  (
+    ~config: Config.resolver,
+    ~key: KeyPress.t,
+    ~context: WhenExpr.ContextKeys.t,
+    model
+  ) =>
   (model, list(effect));
 
 let text: (~text: string, model) => (model, list(effect));
 let keyUp:
-  (~key: KeyPress.t, ~context: WhenExpr.ContextKeys.t, model) =>
+  (
+    ~config: Config.resolver,
+    ~key: KeyPress.t,
+    ~context: WhenExpr.ContextKeys.t,
+    model
+  ) =>
   (model, list(effect));
 
+type uniqueId;
+
+let addKeyBinding:
+  (~binding: Schema.resolvedKeybinding, model) => (model, uniqueId);
+
+let remove: (uniqueId, model) => model;
+
 // UPDATE
 
 let update: (msg, model) => (model, outmsg);
 
-module Contributions: {let commands: list(Command.t(msg));};
+module Contributions: {
+  let commands: list(Command.t(msg));
+  let configuration: list(Config.Schema.spec);
+};