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

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);
+};

src/Input/Handler.re

@@ -7,6 +7,8 @@
 module Log = (val Oni_Core.Log.withNamespace("Oni2.Input.Handler"));
 module Zed_utf8 = Oni_Core.ZedBundled;
 
+open Oni_Core.Utility;
+
 module Internal = {
   let keyCodeToVimString = (keycode, keyString) => {
     let len = Zed_utf8.length(keyString);
@@ -98,25 +100,28 @@ module Internal = {
   };
 };
 
-let keyPressToCommand =
-    (~isTextInputActive, {modifiers, keycode, _}: EditorInput.KeyPress.t) => {
-  let altGr = modifiers.altGr;
-  let shiftKey = modifiers.shift;
-  let altKey = modifiers.alt;
-  let ctrlKey = modifiers.control;
-  let superKey = modifiers.meta;
+let keyPressToCommand = (~isTextInputActive, key) => {
+  let maybeKey = EditorInput.KeyPress.toPhysicalKey(key);
+  maybeKey
+  |> OptionEx.flatMap(({modifiers, keycode, _}: EditorInput.PhysicalKey.t) => {
+       let altGr = modifiers.altGr;
+       let shiftKey = modifiers.shift;
+       let altKey = modifiers.alt;
+       let ctrlKey = modifiers.control;
+       let superKey = modifiers.meta;
 
-  if (altGr && isTextInputActive) {
-    None;
-        // If AltGr is pressed, and we're in text input mode, we'll assume the text input handled it
-  } else {
-    Internal.keyPressToString(
-      ~isTextInputActive,
-      ~shiftKey,
-      ~altKey,
-      ~ctrlKey,
-      ~superKey,
-      keycode,
-    );
-  };
+       if (altGr && isTextInputActive) {
+         None;
+             // If AltGr is pressed, and we're in text input mode, we'll assume the text input handled it
+       } else {
+         Internal.keyPressToString(
+           ~isTextInputActive,
+           ~shiftKey,
+           ~altKey,
+           ~ctrlKey,
+           ~superKey,
+           keycode,
+         );
+       };
+     });
 };

src/Model/State.re

@@ -491,6 +491,7 @@ let initial =
         Feature_AutoUpdate.Contributions.configuration,
         Feature_Buffers.Contributions.configuration,
         Feature_Editor.Contributions.configuration,
+        Feature_Input.Contributions.configuration,
         Feature_SideBar.Contributions.configuration,
         Feature_Syntax.Contributions.configuration,
         Feature_Terminal.Contributions.configuration,

src/Store/InputStoreConnector.re

@@ -171,17 +171,11 @@ let start = (window: option(Revery.Window.t), runEffects) => {
         };
 
       Some(
-        EditorInput.KeyPress.{
-          scancode,
-          keycode,
-          modifiers: {
-            shift,
-            control,
-            alt,
-            meta,
-            altGr,
-          },
-        },
+        EditorInput.KeyPress.physicalKey(
+          ~scancode,
+          ~keycode,
+          ~modifiers={shift, control, alt, meta, altGr},
+        ),
       );
     };
   };
@@ -199,8 +193,9 @@ let start = (window: option(Revery.Window.t), runEffects) => {
   let handleKeyPress = (state: State.t, key) => {
     let context = Model.ContextKeys.all(state);
 
+    let config = Model.Selectors.configResolver(state);
     let (input, effects) =
-      Feature_Input.keyDown(~context, ~key, state.input);
+      Feature_Input.keyDown(~config, ~context, ~key, state.input);
 
     let newState = {...state, input};
 
@@ -224,8 +219,10 @@ let start = (window: option(Revery.Window.t), runEffects) => {
   let handleKeyUp = (state: State.t, key) => {
     let context = Model.ContextKeys.all(state);
 
+    let config = Model.Selectors.configResolver(state);
     //let inputKey = reveryKeyToEditorKey(key);
-    let (input, effects) = Feature_Input.keyUp(~context, ~key, state.input);
+    let (input, effects) =
+      Feature_Input.keyUp(~config, ~context, ~key, state.input);
 
     let newState = {...state, input};