Watch improvements for launchpad

Author: plexus

CHANGELOG.md

@@ -2,8 +2,13 @@
 
 ## Added
 
+- [watcher] Support for custom basis-fn
+- [watcher] Check for aliases in `:extra` deps file
+
 ## Fixed
 
+- [watcher] Fix watcher stop! function
+
 ## Changed
 
 # 0.2.37 (2022-08-26 / 34be62f)

repl_session/poke.clj

@@ -1,6 +1,7 @@
 (ns poke
   (:require [lambdaisland.classpath :as licp]
-            [clojure.string :as str])
+            [clojure.string :as str]
+            [clojure.java.io :as io])
   (:import clojure.lang.DynamicClassLoader))
 
 (licp/classpath-chain)
@@ -28,3 +29,10 @@
         (recur (.getParent loader))))))
 
 (has-dcl? (licp/parent (licp/root-loader)))
+
+(keep (fn [{:local/keys [root]}]
+        (when (and root (.exists (io/file root "shadow-cljs.edn")))
+          root))
+      (vals (:libs (licp/read-basis))))
+
+(io/resource "public/index.html")

src/lambdaisland/classpath/watch_deps.clj

@@ -8,16 +8,41 @@
             [nextjournal.beholder :as beholder])
   (:import java.util.regex.Pattern
            java.nio.file.LinkOption
-           java.nio.file.Paths))
+           java.nio.file.Paths
+           java.nio.file.Path))
 
 (def watcher (atom nil))
 
+(defn path ^Path [root & args]
+  (if (and (instance? Path root) (not (seq args)))
+    root
+    (Paths/get (str root) (into-array String args))))
+
 (defn canonical-path [p]
-  (.toRealPath (Paths/get p (into-array String [])) (into-array LinkOption [])))
+  (.toRealPath (path p) (into-array LinkOption [])))
+
+(defn parent-path [p]
+  (.getParent (path p)))
 
 (def process-root-path (canonical-path "."))
 
-(defn- on-event [deps-path opts {:keys [type path]}]
+(defn basis
+  "Default function for (re-)computing the tools.deps basis, which we then use to
+  update the classpath. Delegates to [[deps/create-basis]], with one addition:
+  if you include an `:extra` option which points at a file (string), then we
+  also look in that file for a `:lambdaisland.classpath/aliases`, which are
+  additional alias keys to load. This allows having a `deps.local.edn`, where
+  you can change the aliases in use without restarting."
+  [opts]
+  (if-let [f (:basis-fn opts)]
+    (f opts)
+    (deps/create-basis
+     (if (string? (:extra opts))
+       (update opts :aliases into (:lambdaisland.classpath/aliases
+                                   (deps/slurp-deps (io/file (:extra opts)))))
+       opts))))
+
+(defn- on-event [deps-paths opts {:keys [type path]}]
   (locking watcher
     (when (and (= :modify type)
                ;; Before we used "." as the watch path, resulting in a
@@ -28,13 +53,13 @@
                ;; We now turn `"."` into a canonical path before starting the
                ;; watcher, which means we get fully qualified filenames for both
                ;; in this equality check.
-               (= path deps-path))
+               (some #{path} deps-paths))
       (try
         (println "[watch-deps] ✨ Reloading"
                  (str (.relativize process-root-path path))
                  "✨")
         (let [added-paths (remove (set (map str (cp/system-classpath)))
-                                  (:classpath-roots (deps/create-basis opts)))]
+                                  (:classpath-roots (basis opts)))]
           (when (not (seq added-paths))
             (println "[watch-deps] No new libraries to add."))
           (doseq [path added-paths]
@@ -60,31 +85,36 @@
            (when w
              (println "Stopping existing `deps.edn' watchers")
              (run! beholder/stop w))
-           (let [basis (deps/create-basis opts)
-                 roots (cons (str process-root-path)
-                             (when (:include-local-roots? opts)
-                               (->> (vals (:libs basis))
-                                    (keep :local/root)
-                                    (map canonical-path)
-                                    (map str))))]
+           (let [basis (basis opts)
+                 deps-paths (cond-> [(path process-root-path "deps.edn")]
+                              (:include-local-roots? opts)
+                              (into (->> (vals (:libs basis))
+                                         (keep :local/root)
+                                         (map canonical-path)
+                                         (map #(path % "deps.edn"))))
+                              (string? (:extra opts))
+                              (conj (canonical-path (:extra opts))))
+                 roots (group-by parent-path deps-paths)]
+             (prn roots)
              (doall
-              (for [root roots]
+              (for [[root deps-paths] roots]
                 (beholder/watch
-                 (partial #'on-event (Paths/get root (into-array String ["deps.edn"])) opts)
-                 root)))))))
+                 (partial #'on-event deps-paths opts)
+                 (str root))))))))
 
 (defn stop!
   "Stop a previously started watcher"
-  [opts]
+  [& _]
   (swap! watcher
          (fn [w]
-           (when w
-             (beholder/stop w))
+           (run! beholder/stop w)
            nil)))
 
 (comment
-  (start! {:aliases [:dev]})
+  (start! {:aliases [:dev]
+           :extra "deps.local.edn"})
 
+  (stop!)
   (deps/create-basis {:aliases [:backend]
                       :extra '{cider/cider-nrepl #:mvn{:version "0.28.5"}
                                refactor-nrepl/refactor-nrepl #:mvn{:version "3.5.2"}}})