Merge pull request #160 from geksilla/feature/disable-packages

Added configuration option to disable packages

plugin/templates/proton.edn

@@ -60,6 +60,15 @@
     ;; :pigments
   ]
 
+  ;; Packages that you want to disable.
+  ;; Note that packages will be removed except bundled packages.
+  ;; Bundled packages will be disabled instead.
+  ;; Use this configuration instead of atom's `core.disabledPackages`
+  :disabled-packages [
+    ;; :autoupdate-packages
+    ;; :about
+    ;; :welcome
+  ]
   ;; Proton takes over your atom configuration. All settings that are not listed here will get wiped
   ;; Configurations are denoted as 2 element vector consisting of k/v
   ;; sub-vectors inside v will get treated like javascript arrays

src/cljs/proton/core.cljs

@@ -95,7 +95,7 @@
     (proton/init-proton-mode-keymaps!)
     (atom-env/show-modal-panel)
     (atom-env/insert-process-step! "Initialising proton... Just a moment!" "")
-    (let [{:keys [additional-packages layers configuration keybindings keymaps]} (proton/load-config)
+    (let [{:keys [additional-packages layers configuration disabled-packages keybindings keymaps]} (proton/load-config)
           editor-default editor-config/default
           proton-default proton-config/default]
       (let [all-layers (into [] (distinct (concat (:layers proton-default) layers)))
@@ -107,13 +107,12 @@
         (atom-env/mark-last-step-as-completed!)
 
         (let [layer-packages (into [] (distinct (concat (proton/packages-for-layers all-layers) additional-packages)))
-              all-packages (into [] (distinct (concat layer-packages (:core-packages editor-default))))
+              selected-packages (into [] (distinct (concat layer-packages (:core-packages editor-default))))
               all-keymaps (into [] (distinct (concat keymaps (:keymaps editor-default) (proton/keymaps-for-layers all-layers))))
               all-keybindings (helpers/deep-merge (proton/keybindings-for-layers all-layers) keybindings)
-              wipe-configs? (true? (config-map "proton.core.wipeUserConfigs"))]
-
+              wipe-configs? (true? (config-map "proton.core.wipeUserConfigs"))
+              all-packages (pm/register-packages (into (hash-map) (concat (map pm/register-installable selected-packages) (map pm/register-removable disabled-packages))))]
           ;; wipe existing config
-
           (when wipe-configs?
             (do
               (atom-env/insert-process-step! "Wiping existing configuration")
@@ -122,7 +121,6 @@
                                                           (atom-env/get-all-settings))))
               (atom-env/mark-last-step-as-completed!)))
           (atom-env/set-config! "proton.core.selectedLayers" (clj->js (map #(subs (str %) 1) all-layers)))
-          (pm/register-packages all-packages)
           ; avoid duplicates
           (atom-env/set-config! "core.disabledPackages" (distinct (array-seq (atom-env/get-config "core.disabledPackages"))))
 

src/cljs/proton/lib/atom.cljs

@@ -1,13 +1,16 @@
 (ns proton.lib.atom
+  (:require-macros [cljs.core.async.macros :refer [go]])
   (:require [proton.lib.helpers :refer [generate-div process->html deep-merge console!]]
             [cljs.nodejs :as node]
-            [clojure.string :as string :refer [lower-case upper-case]]))
+            [clojure.string :as string :refer [lower-case upper-case]]
+            [cljs.core.async :as async :refer [chan >!]]))
 
 ;; reference to atom shell API
 (def ashell (node/require "atom"))
 
 ;; get atom.CompositeDisposable so we can work with it
 (def composite-disposable (.-CompositeDisposable ashell))
+(def buffered-process (.-BufferedProcess ashell))
 
 ;; Initialise new composite-disposable so we can add stuff to it later
 (def subscriptions (new composite-disposable))
@@ -194,6 +197,9 @@
     (let [pkgs (get-all-packages)]
       (not (= -1 (.indexOf pkgs package-name))))))
 
+(defn is-package-bundled? [package-name]
+  (.isBundledPackage packages (name package-name)))
+
 (defn enable-package [package-name]
   (console! (str "enabling package " (name package-name)))
   (.enablePackage packages package-name))
@@ -221,3 +227,13 @@
 (defn force-reload-package [package-name]
   (disable-package package-name true)
   (enable-package package-name))
+
+(defn buffered-process-> [command args]
+  (let [out-chan (chan)]
+    (new buffered-process
+      (clj->js
+        { :command command
+          :args args
+          :stdout #(go (>! out-chan {:stdout %}))
+          :stderr #(when-not (nil? %) (go (>! out-chan {:stderr %})))}))
+    out-chan))

src/cljs/proton/lib/package_manager.cljs

@@ -1,6 +1,7 @@
 (ns proton.lib.package_manager
   (:require-macros [cljs.core.async.macros :refer [go go-loop]])
   (:require [cljs.nodejs :as node]
+            [clojure.set :as cljset]
             [cljs.core.async :as async :refer [close! chan put! pub sub unsub >! <!]]
             [proton.lib.mode :as mode]
             [proton.lib.keymap :as keymap]
@@ -16,9 +17,59 @@
 (defn cleanup! []
   (reset! packages {}))
 
-(defn register-packages [package-names]
-  (let [packages-map (reduce #(assoc-in %1 [%2] {:atom-disabled (atom/is-package-disabled? (name %2))}) {} package-names)]
-    (swap! packages #(helpers/deep-merge packages-map %))))
+(defn atom-state-info [package-name]
+  (let [p-name (name package-name)]
+    {:atom-disabled (atom/is-package-disabled? p-name)
+     :bundled (atom/is-package-bundled? p-name)}))
+
+(defn update-in-package [package & props]
+  {:pre [(even? (count props))]}
+  (update-in package [(first (keys package))] merge (apply hash-map props)))
+
+(defn make-package
+  ([package-name]
+   (make-package package-name {}))
+  ([package-name opts]
+   (assoc {} (keyword package-name) opts)))
+
+(defn- package-init-state? [package state]
+  (-> package (val) (get :init-state) (= state)))
+
+(defn is-installable? [package]
+  (package-init-state? package :installed))
+
+(defn is-removable? [package]
+  (package-init-state? package :removed))
+
+(defn is-bundled? [package]
+  (true? (get (val package) :bundled)))
+
+(defn register-init-state [package-name state]
+  (-> package-name
+      (atom-state-info)
+      (merge {:init-state state})
+      (->> (make-package package-name))))
+
+(defn register-installable [package-name]
+  (register-init-state package-name :installed))
+
+(defn register-removable [package-name]
+  (-> package-name
+      (register-init-state :removed)
+      (update-in-package :proton-disabled true)))
+
+(defn- update-bundled-removable [package]
+  (if (is-bundled? package)
+    (if (is-removable? package)
+      (update-in (hash-map package) [(key package)] assoc :init-state :installed :proton-disabled true)
+      package)
+    package))
+
+(defn register-packages [packages-map]
+  (let [all-available (into (hash-map) (map (comp register-installable keyword) (array-seq (atom/get-all-packages))))
+        pkgs (into (hash-map) (map update-bundled-removable (merge all-available packages-map)))]
+    (swap! packages helpers/deep-merge pkgs)
+    @packages))
 
 (defn set-installed! [package-name]
   (swap! packages assoc-in [(keyword package-name) :atom-disabled] false))
@@ -41,12 +92,14 @@
   (swap! packages update-in [(keyword package-name)] assoc :atom-disabled true :proton-disabled true))
 
 (defn get-to-remove [all-packages]
-  (let [pkgs (set all-packages)]
-    (filter #(if (not (contains? pkgs %)) %) (into [] (map keyword (atom/get-all-packages))))))
+  (let [installed-pkgs (set (map keyword (atom/get-all-packages)))
+        removable (set (keys (filter is-removable? all-packages)))]
+    (cljset/intersection removable installed-pkgs)))
 
 (defn get-to-install [all-packages]
-  (let [pkgs (set (into [] (map keyword (atom/get-all-packages))))]
-    (filter #(if (not (contains? pkgs %)) %) all-packages)))
+  (let [installed-pkgs (set (map keyword (atom/get-all-packages)))
+        installable (set (keys (filter is-installable? all-packages)))]
+    (cljset/difference installable installed-pkgs)))
 
 (defn activate-packages! []
   (let [enabled-packages (filter #(not ((val %) :proton-disabled)) @packages)