CLJS-2680: Passing :watch-fn via --compile-opts to cljs.main

Author: mfikes

src/main/clojure/cljs/closure.clj

@@ -54,6 +54,35 @@
 (defn random-string [length]
   (apply str (take length (repeatedly random-char))))
 
+(defn- sym->var
+  "Converts a namespaced symbol to a var, loading the requisite namespace if
+  needed. For use with a function defined under a keyword in opts. The kw and
+  ex-data arguments are used to form exceptions."
+  [sym kw ex-data]
+  (let [ns     (namespace sym)
+        _      (when (nil? ns)
+                 (throw
+                   (ex-info (str kw " symbol " sym " is not fully qualified")
+                     (merge ex-data {kw sym}))))
+        var-ns (symbol ns)]
+    (when (not (find-ns var-ns))
+      (try
+        (locking ana/load-mutex
+          (require var-ns))
+        (catch Throwable t
+          (throw (ex-info (str "Cannot require namespace referred by " kw " value " sym)
+                   (merge ex-data {kw sym})
+                   t)))))
+
+    (find-var sym)))
+
+(defn- opts-fn
+  "Extracts a function from opts, by default expecting a function value, but
+  converting from a namespaced symbol if needed."
+  [kw opts]
+  (when-let [fn-or-sym (kw opts)]
+    (cond-> fn-or-sym (symbol? fn-or-sym) (sym->var kw {}))))
+
 ;; Closure API
 ;; ===========
 
@@ -2469,30 +2498,14 @@
     (js-transforms js-module opts)
 
     (symbol? preprocess)
-    (let [ns (namespace preprocess)
-          _ (when (nil? ns)
-              (throw
-                (ex-info (str "Preprocess symbol " preprocess " is not fully qualified")
-                  {:file (:file js-module)
-                   :preprocess preprocess})))
-          preprocess-ns (symbol ns)]
-      (when (not (find-ns preprocess-ns))
-        (try
-          (locking ana/load-mutex
-            (require preprocess-ns))
-          (catch Throwable t
-            (throw (ex-info (str "Cannot require namespace referred by :preprocess value " preprocess)
-                            {:file (:file js-module)
-                             :preprocess preprocess}
-                            t)))))
-
+    (let [preprocess-var (sym->var preprocess :preprocess {:file (:file js-module)})]
       (try
-        ((find-var preprocess) js-module opts)
+        (preprocess-var js-module opts)
         (catch Throwable t
           (throw (ex-info (str "Error running preprocessing function " preprocess)
-                          {:file (:file js-module)
-                           :preprocess preprocess}
-                          t)))))
+                   {:file       (:file js-module)
+                    :preprocess preprocess}
+                   t)))))
 
     :else
     (do
@@ -2895,8 +2908,13 @@
   "Given a source directory, produce runnable JavaScript. Watch the source
    directory for changes rebuilding when necessary. Takes the same arguments as
    cljs.closure/build in addition to some watch-specific options:
-    - :watch-fn, a function of no arguments to run after a successful build.
-    - :watch-error-fn, a function receiving the exception of a failed build."
+    - :watch-fn, a function of no arguments to run after a successful build. May
+                 be a function value or a namespaced symbol identifying a function,
+                 in which case the associated namespace willl be loaded and the
+                 symbol resolved.
+    - :watch-error-fn, a function receiving the exception of a failed build. May
+                       be a function value or a namespaced symbol, loaded as
+                       with :watch-fn."
   ([source opts]
     (watch source opts
       (if-not (nil? env/*compiler*)
@@ -2919,10 +2937,10 @@
                     (println "... done. Elapsed"
                       (/ (unchecked-subtract (System/nanoTime) start) 1e9) "seconds")
                     (flush))
-                  (when-let [f (:watch-fn opts)]
+                  (when-let [f (opts-fn :watch-fn opts)]
                     (f))
                   (catch Throwable e
-                    (if-let [f (:watch-error-fn opts)]
+                    (if-let [f (opts-fn :watch-error-fn opts)]
                       (f e)
                       (binding [*out* *err*]
                         (println (Throwables/getStackTraceAsString e)))))))

src/test/cljs_cli/cljs_cli/test.clj

@@ -4,7 +4,8 @@
    [clojure.java.io :as io]
    [clojure.java.shell :as shell :refer [with-sh-dir]]
    [clojure.string :as str]
-   [cljs-cli.util :refer [cljs-main output-is with-sources with-post-condition with-repl-env-filter]]))
+   [cljs-cli.util :refer [cljs-main output-is with-sources with-in with-post-condition with-repl-env-filter repl-title]]
+   [clojure.string :as string]))
 
 (deftest eval-test
   (-> (cljs-main "-e" 3 "-e" nil "-e" 4)
@@ -96,3 +97,29 @@
       (output-is
         nil
         "{:ns cljs.user, :value 3}"))))
+
+(deftest test-cljs-2680
+  (with-repl-env-filter (complement #{"node"})                    ; Exclude Node owing to CLJS-2684
+    (with-sources {"src/foo/core.cljs" "(ns foo.core)"
+                   "src/bar/core.clj"  "(ns bar.core) (defn watch [] (prn :watch-called))"}
+      (with-in ":cljs/quit\n"
+        (with-post-condition (fn [dir]
+                               (some #{":watch-called"}
+                                 (str/split-lines (slurp (io/file dir "out" "watch.log")))))
+          (-> (cljs-main "-co" "{:watch-fn bar.core/watch}" "--watch" "src" "-c" "foo.core" "-r")
+            (output-is
+              "Watch compilation log available at: out/watch.log"
+              (repl-title)
+              "cljs.user=>")))))
+    (with-sources {"src/foo/core.cljs" "(ns foo.core"
+                   "src/bar/core.clj"  "(ns bar.core) (defn watch-error [e] (prn :watch-error-called (.getMessage e)))"}
+      (with-in ":cljs/quit\n"
+        (with-post-condition (fn [dir]
+                               (let [log-contents (slurp (io/file dir "out" "watch.log"))]
+                                 (and (str/includes? log-contents ":watch-error-called")
+                                   (str/includes? log-contents "Unexpected EOF while reading"))))
+          (-> (cljs-main "-co" "{:watch-error-fn bar.core/watch-error}" "--watch" "src" "-c" "foo.core" "-r")
+            (output-is
+              "Watch compilation log available at: out/watch.log"
+              (repl-title)
+              "cljs.user=>")))))))

src/test/cljs_cli/cljs_cli/util.clj

@@ -1,9 +1,11 @@
 (ns cljs-cli.util
+  (:refer-clojure :exclude [*in*])
   (:require
    [clojure.string :as string]
    [clojure.java.io :as io]
    [clojure.java.shell :as shell]
-   [clojure.test :refer [is]])
+   [clojure.test :refer [is]]
+   [cljs.repl :as repl])
   (:import
    (java.io File)
    (java.nio.file Files CopyOption)
@@ -13,13 +15,20 @@
 (def ^:dynamic *repl-env-filter* (constantly true))
 (def ^:dynamic *repl-opts* nil)
 (def ^:dynamic *sources* nil)
+(def ^:dynamic *in* nil)
 (def ^:dynamic *post-condition* nil)
 
 (defmacro with-sources
   [sources & body]
   `(binding [*sources* ~sources]
      ~@body))
 
+
+(defmacro with-in
+  [in & body]
+  `(binding [*in* ~in]
+     ~@body))
+
 (defmacro with-post-condition
   [post-condition & body]
   `(binding [*post-condition* ~post-condition]
@@ -54,7 +63,7 @@
       (copy-uberjar temp-dir)
       (let [result (shell/with-sh-dir temp-dir
                      #_(apply println "running:" args)
-                     (apply shell/sh args))]
+                     (apply shell/sh (if *in* (concat args [:in *in*]) args)))]
         (when *post-condition*
           (is (*post-condition* temp-dir)))
         result)
@@ -90,5 +99,8 @@
   (is (zero? (:exit result)))
   (maybe-print-result-err result)
   (when-not (:repl-env-filtered result)
-    (is (= (apply str (map print-str (interleave expected-lines (repeat "\n"))))
-          (:out result)))))
+    (is (= (string/trim (apply str (map print-str (interleave expected-lines (repeat "\n")))))
+          (string/trim (:out result))))))
+
+(defn repl-title []
+  (string/trim (with-out-str (repl/repl-title))))