feat(core): Provide option to chose input mode for non-vim users. (dvcrn#222)

* Added option `proton.core.inputProvider` with default value
 `:vim-mode-plus`. Available options are `:vim-mode-plus`, `:vim-mode`,
 `:atomic-emacs`, `:default`
* Added deprecated warning for `proton.core.vim-provider` option.
* Added options `proton.core.leaderKey` and `proton.core.modeKey` to
 configure leader and major mode alias keystrokes
* Added info regarding `proton.core.leaderKey`, `proton.core.modeKey`,
 `proton.core.inputProvider` to core layer Readme.

Author: geksilla

plugin/templates/proton.edn

@@ -88,7 +88,7 @@
     ["proton.core.relativeLineNumbers" false]
 
     ;; prefer classic vim mode over vim-mode-plus? Change this to :vim-mode
-    ["proton.core.vim-provider" :vim-mode-plus]
+    ["proton.core.inputProvider" :vim-mode-plus]
   ]
 
   ;; Don't like a keybinding or want to add something yourself? Do it here

src/cljs/proton/config/editor.cljs

@@ -5,7 +5,10 @@
                ["welcome.showOnStartup" false]
 
                ;; Better default font ;)
-               ["editor.fontFamily" "Hack"]]
+               ["editor.fontFamily" "Hack"]
+               ["proton.core.leaderKey" "space"]
+               ["proton.core.modeKey" ","]
+               ["proton.core.inputProvider" :vim-mode-plus]]
 
               :keymaps
                []

src/cljs/proton/core.cljs

@@ -173,6 +173,7 @@
           ;; set the user config
           (atom-env/insert-process-step! "Applying user configuration")
           (doall (map #(apply atom-env/set-config! %) all-configuration))
+          (proton/show-deprecated-configs all-configuration)
           (atom-env/mark-last-step-as-completed!)
 
           ;; Make sure all collected packages are definitely enabled

src/cljs/proton/layers/core/README.md

@@ -8,15 +8,18 @@ The core layer should get included by default. No installation needed.
 
 ### Configuration
 
-| Name                              | Default        | Type        | Description                                                                                |
-|-----------------------------------|----------------|-------------|--------------------------------------------------------------------------------------------|
-| `proton.core.showTabBar`          | false          | __boolean__ | whether the tab bar should be visible by default                                           |
-| `proton.core.relativeLineNumbers` | false          | __boolean__ | whether to use relative line numbers instead of absolute ones                              |
-| `proton.core.vim-provider`        | :vim-mode-plus | __keyword__ | which vim emulation provider to use. Possible options are `:vim-mode-plus` and `:vim-mode` |
-| `proton.core.wipeUserConfigs`     | true           | __boolean__ | always reset atom configuration before applying conifgs from layers and `~/.proton`        |
-| `proton.core.whichKeyDelay`       | 0.4            | __number__  | which-key modal delay in seconds                                                           |
-| `proton.core.whichKeyDelayOnInit` | false          | __boolean__ | which-key modal delay for first show up and no delay when shown                            |
-| `proton.core.whichKeyDisabled` | false          | __boolean__ | which-key modal always hidden |
+| Name                              | Default        | Type        | Description                                                                                                                                 |
+|-----------------------------------|----------------|-------------|---------------------------------------------------------------------------------------------------------------------------------------------|
+| `proton.core.showTabBar`          | false          | __boolean__ | whether the tab bar should be visible by default                                                                                            |
+| `proton.core.relativeLineNumbers` | false          | __boolean__ | whether to use relative line numbers instead of absolute ones                                                                               |
+| `proton.core.vim-provider`        | :vim-mode-plus | __keyword__ | which vim emulation provider to use. Possible options are `:vim-mode-plus` and `:vim-mode`                                                  |
+| `proton.core.wipeUserConfigs`     | true           | __boolean__ | always reset atom configuration before applying conifgs from layers and `~/.proton`                                                         |
+| `proton.core.whichKeyDelay`       | 0.4            | __number__  | which-key modal delay in seconds                                                                                                            |
+| `proton.core.whichKeyDelayOnInit` | false          | __boolean__ | which-key modal delay for first show up and no delay when shown                                                                             |
+| `proton.core.whichKeyDisabled`    | false          | __boolean__ | which-key modal always hidden                                                                                                               |
+| `proton.core.inputProvider`       | :vim-mode-plus | __keyword__ | editor input. available options are :vim-mode-plus, :vim-mode, :emacs, :default. You need to reload editor to apply changes properly |
+| `proton.core.leaderKey`           | "space"        | __string__  | proton leader key binding. For non-vim modes its value is `alt-m` if not set manualy by user                                                |
+| `proton.core.modeKey`             | ","            | __string__  | proton major mode key alias to quickly invoke `SPC m`. For non-vim modes its value is `ctrl-alt-m` if not set by user                       |
 
 
 ### Key Bindings

src/cljs/proton/layers/core/core.cljs

@@ -9,6 +9,9 @@
             [proton.lib.atom :as atom-env :refer [get-config set-config! set-keymap!]]
             [cljs.nodejs :as node]))
 
+(defn- add-packages [p]
+  (swap! packages #(into [] (concat % p))))
+
 (def keymaps (atom
               [{:selector "body" :keymap [["ctrl-j" "core:move-down"]
                                           ["ctrl-k" "core:move-up"]]}
@@ -26,7 +29,6 @@
    ["proton.core.relativeLineNumbers" false]
    ["proton.core.quickOpenProvider" :normal]
    ["proton.core.post-init-timeout" 3000]
-   ["proton.core.vim-provider" :vim-mode-plus]
    ["proton.core.wipeUserConfigs" true]
    ["proton.core.whichKeyDelay" 0.4]
    ["proton.core.whichKeyDelayOnInit" false]
@@ -69,9 +71,12 @@
     (swap! state assoc-in [:relative-numbers] (config-map "proton.core.relativeLineNumbers"))
     (swap! state assoc-in [:tabs] (config-map "proton.core.showTabBar"))
 
-    (case (config-map "proton.core.vim-provider")
-      :vim-mode (swap! packages #(into [] (concat % [:vim-mode :vim-surround])))
-      :vim-mode-plus (swap! packages #(into [] (concat % [:vim-mode-plus :vim-mode-plus-ex-mode]))))))
+    ;; install additional packages based on proton.core.inputProvider if needed
+    (case (config-map "proton.core.inputProvider")
+      :vim-mode (add-packages [:vim-mode :vim-surround])
+      :vim-mode-plus (add-packages [:vim-mode-plus :vim-mode-plus-ex-mode])
+      :emacs (add-packages [:atomic-emacs])
+      :default)))
 
 (defmethod init-package [:core :theme-switch] []
   (let [core-themes (string/join " " (atom-env/get-config "core.themes"))

src/cljs/proton/lib/atom.cljs

@@ -23,6 +23,7 @@
 (def grammars (.-grammars (.-grammars js/atom)))
 (def workspace-view (.getView views workspace))
 (def packages (.-packages js/atom))
+(def notifications (.-notifications js/atom))
 
 (def element (atom (generate-div "test" "proton-which-key")))
 (def bottom-panel (atom (.addBottomPanel workspace
@@ -99,20 +100,22 @@
   (amend-last-step! (str (get (last @steps) 0)) "<span class='proton-status-ok'>[ok]</span>"))
 
 (defn input-provider-class []
-  (if-let [selected-provider (get-config "proton.core.vim-provider")]
+  (if-let [selected-provider (get-config "proton.core.inputProvider")]
     (do
       (case selected-provider
         "vim-mode" ["vim-mode"]
-        "vim-mode-plus" ["vim-mode-plus"]))
-    [""]))
+        "vim-mode-plus" ["vim-mode-plus"]
+        []))
+    []))
 
 (defn editor-toggle-classes [class-list remove?]
-  (let [editors (.getTextEditors workspace)]
-    (doseq [editor editors]
-      (let [editor-view (.getView views editor)
-            classList (.-classList editor-view)
-            class-list-fn (fn [class-name] (if remove? (.remove classList class-name) (.add classList class-name)))]
-        (doall (map class-list-fn class-list))))))
+  (when (not (empty? class-list))
+    (let [editors (.getTextEditors workspace)]
+      (doseq [editor editors]
+        (let [editor-view (.getView views editor)
+              classList (.-classList editor-view)
+              class-list-fn (fn [class-name] (if remove? (.remove classList class-name) (.add classList class-name)))]
+          (doall (map class-list-fn class-list)))))))
 
 (defn activate-proton-mode! []
   (console! "Chain activated!")
@@ -170,7 +173,6 @@
                 (swap! parsed-config conj (str config-prefix "." config-postfix))))))))
     @parsed-config))
 
-
 (defn set-keymap!
   ([selector bindings]
    (set-keymap! selector bindings 0))

src/cljs/proton/lib/helpers.cljs

@@ -143,7 +143,8 @@
         ignored-editor-classes #{"insert-mode" "mini"}
         ignored-editor-class-ok? (empty? (cljset/intersection class-list ignored-editor-classes))
         required-editor-classes #{"vim-mode" "vim-mode-plus"}
-        required-editor-class-ok? (not (empty? (cljset/intersection class-list required-editor-classes)))]
+        vim-mode? (some #{(js/atom.config.get "proton.core.inputProvider")} ["vim-mode" "vim-mode-plus"])
+        required-editor-class-ok? (or (not (empty? (cljset/intersection class-list required-editor-classes))) (not vim-mode?))]
     (if tag-ok?
       (if (= tag-name "atom-text-editor")
         (and required-editor-class-ok? ignored-attrs-ok? ignored-editor-class-ok?)

src/cljs/proton/lib/proton.cljs

@@ -2,7 +2,7 @@
   #_(:require [proton.core])
   (:require [cljs.reader :as reader]
             [cljs.nodejs :as node]
-            [clojure.string :as string :refer [upper-case join]]
+            [clojure.string :as string :refer [upper-case join starts-with?]]
             [proton.lib.mode :as mode-manager]
             [proton.lib.helpers :as helpers]
             [proton.lib.atom :as atom-env]
@@ -90,17 +90,51 @@
         ret-map (reduce #(assoc %1 %2 command) {} (map identity ret))]
       (atom-env/set-keymap! selector ret-map 100)))
 
+(defn- vim-input? [provider] (some #{provider} [:vim-mode :vim-mode-plus]))
+
+(defn- configure-leader-keys [config-map]
+  (let [vim-provider? (vim-input? (config-map "proton.core.inputProvider"))
+        current-keys [(config-map "proton.core.leaderKey") (config-map "proton.core.modeKey")]
+        vim-keys ["space" ","]
+        non-vim-keys ["alt-m" "ctrl-alt-m"]]
+      (cond
+        (and vim-provider? (= non-vim-keys current-keys)) vim-keys
+        (and (not vim-provider?) (= vim-keys current-keys)) non-vim-keys
+        :else current-keys)))
+
+(defn- clear-conflicted-keystrokes! [keystrokes]
+  (let [reg (re-pattern (str "^(" (join "|" keystrokes) ")"))]
+    (set! (.-keyBindings atom-env/keymaps)
+      (clj->js
+        (filter
+          #(not (and (re-find reg (.-keystrokes %)) (not (re-find (re-pattern "^proton:") (.-command %)))))
+           (array-seq atom-env/keymaps.keyBindings))))))
+
 (defn init-proton-leader-keys! [configs]
   (let [config-map (into (hash-map) configs)
-        selectors ["body atom-workspace:not(.proton-mode) atom-text-editor:not([mini]):not(.insert-mode)"
-                   "body atom-workspace:not(.proton-mode) atom-panel-container.left"
-                   "body atom-workspace:not(.proton-mode) atom-panel-container.right"
-                   "body atom-workspace:not(.proton-mode) atom-panel-container.bottom"
-                   "atom-workspace:not(.proton-mode)"]
+        vim-provider? (vim-input? (config-map "proton.core.inputProvider"))
+        selectors (conj
+                    ["body atom-workspace:not(.proton-mode) atom-panel-container.left"
+                     "body atom-workspace:not(.proton-mode) atom-panel-container.right"
+                     "body atom-workspace:not(.proton-mode) atom-panel-container.bottom"
+                     "atom-workspace:not(.proton-mode)"]
+                    (if vim-provider?
+                       "body atom-workspace:not(.proton-mode) atom-text-editor:not([mini]):not(.insert-mode)"
+                       "body atom-workspace:not(.proton-mode) atom-text-editor:not([mini])"))
         selector (string/join ", " selectors)
         leader-command "proton:toggle"
-        proton-leader-key "space"
-        proton-mode-key (name (nth proton.core/mode-keys 1))
+        proton-keys (configure-leader-keys config-map)
+        proton-leader-key (proton-keys 0)
+        proton-mode-key (proton-keys 1)
         mode-command "proton:toggleMode"
         keymap (hash-map proton-leader-key leader-command proton-mode-key mode-command)]
+    (when (not vim-provider?)
+      (clear-conflicted-keystrokes! [proton-leader-key proton-mode-key]))
     (atom-env/set-keymap! selector keymap 100)))
+
+(defn show-deprecated-configs [configs]
+  (let [config-map (into (hash-map) configs)]
+    (when (config-map "proton.core.vim-provider")
+      (.addInfo atom-env/notifications "proton-mode: deprecated config <strong>proton.core.vim-provider</strong>"
+        (clj->js {:detail "Please use proton.core.inputProvider"
+                  :dismissable true})))))