Make tools.logging works as expected in CLJ and CLJS

deps.edn

@@ -1,7 +1,7 @@
-{:paths ["src" "resources" "target/classes"],
+{:paths ["src" "resources"],
  :deps
  {funcool/promesa
-  {:git/sha "aee3828d2ba1056de38a06050d5939c3d86dc440"
+  {:git/sha "bbef8d79bf1aa27c8aa2f889a66a946a8657a438"
    :git/url "https://github.com/funcool/promesa.git"}
   org.slf4j/slf4j-api {:mvn/version "2.0.5"}
   expound/expound {:mvn/version "0.9.0"}
@@ -19,7 +19,7 @@
     criterium/criterium {:mvn/version "RELEASE"}
     thheller/shadow-cljs {:mvn/version "RELEASE"}
     org.slf4j/slf4j-simple {:mvn/version "2.0.5"}}
-   :extra-paths ["test" "dev" "src"]},
+   :extra-paths ["test" "dev" "src" "target/examples"]},
 
   :repl
   {:main-opts  ["-m" "rebel-readline.main"]}

dev/funcool/tools/examples.cljs

@@ -0,0 +1,30 @@
+(ns funcool.tools.examples
+  (:require
+   [funcool.tools.logging :as l]
+   [promesa.core :as p]
+   [promesa.protocols :as pt]
+   [promesa.exec :as px]
+   [clojure.spec.alpha :as s]))
+
+(enable-console-print!)
+
+(l/set-level! :debug)
+
+(s/def ::foo int?)
+(s/def ::bar string?)
+(s/def ::foobar
+  (s/keys :req-un [::foo ::bar]))
+
+(defn main
+  [& args]
+  (js/console.log "main" args))
+
+(defn ^:dev/after-load after-load
+  []
+  (let [data (s/explain-data ::foobar {:a 1})]
+    (l/info :hello "world")
+    (l/error :hello "error"
+             :js/sample #js {:a 1 :b 2}
+             :cause (ex-info "assertion error" data))))
+
+

dev/user.clj

@@ -0,0 +1,48 @@
+(ns user
+  (:require
+   [clojure.pprint :refer [pprint]]
+   [clojure.test :as test]
+   [clojure.tools.namespace.repl :as r]
+   [clojure.walk :refer [macroexpand-all]]
+   [clojure.core.async :as a]
+   [criterium.core :refer [quick-bench bench with-progress-reporting]]
+   [promesa.core :as p]
+   [promesa.exec :as px]))
+
+(defmacro run-quick-bench
+  [& exprs]
+  `(with-progress-reporting (quick-bench (do ~@exprs) :verbose)))
+
+(defmacro run-quick-bench'
+  [& exprs]
+  `(quick-bench (do ~@exprs)))
+
+(defmacro run-bench
+  [& exprs]
+  `(with-progress-reporting (bench (do ~@exprs) :verbose)))
+
+(defmacro run-bench'
+  [& exprs]
+  `(bench (do ~@exprs)))
+
+(defn- run-test
+  ([] (run-test #"^funcool.*"))
+  ([o]
+   ;; (r/refresh)
+   (cond
+     (instance? java.util.regex.Pattern o)
+     (test/run-all-tests o)
+
+     (symbol? o)
+     (if-let [sns (namespace o)]
+       (do (require (symbol sns))
+           (test/test-vars [(resolve o)]))
+       (test/test-ns o)))))
+
+;; (defn -main
+;;   [& args]
+;;   (require 'promesa.tests.test-core)
+;;   (let [{:keys [fail]} (run-test)]
+;;     (if (pos? fail)
+;;       (System/exit fail)
+;;       (System/exit 0))))

package.json

@@ -12,6 +12,7 @@
     "watch-test": "clojure -M:dev:shadow-cljs watch test",
     "compile-test": "clojure -M:dev:shadow-cljs compile test --config-merge '{:autorun false}'",
     "run-test": "node target/tests.js",
+    "examples-watch": "clojure -M:dev:shadow-cljs watch examples",
     "test": "npm run compile-test && npm run run-test"
   },
   "devDependencies": {

shadow-cljs.edn

@@ -0,0 +1,36 @@
+{:deps {:aliases [:dev]}
+ :http {:port 3448}
+ :nrepl {:port 3447 :host "0.0.0.0"}
+ :jvm-opts ["-Xmx700m" "-Xms100m" "-XX:+UseSerialGC" "-XX:-OmitStackTraceInFastThrow"]
+ :dev-http {8889 "target/examples"}
+
+ :builds
+ {
+  ;; :test
+  ;; {:target :node-test
+  ;;  :output-to "target/tests.js"
+  ;;  :output-dir "target/test/"
+  ;;  :ns-regexp "^promesa.tests.*-test$"
+  ;;  :autorun true
+
+  ;;  :compiler-options
+  ;;  {:output-feature-set :es2020
+  ;;   :output-wrapper false
+  ;;   :source-map true
+  ;;   :source-map-include-sources-content true
+  ;;   :source-map-detail-level :all
+  ;;   :warnings {:fn-deprecated false}}}
+
+  :examples
+  {:target :browser
+   :output-dir "target/examples/js"
+   :asset-path "/js"
+   :modules {:main {:entries [funcool.tools.examples]}}
+   :compiler-options {:output-feature-set :es-next}
+   :release
+   {:compiler-options
+    {:pseudo-names true
+     :pretty-print true}}}
+
+  }}
+

src/funcool/tools/exceptions.cljc

@@ -81,105 +81,105 @@
          (s/explain-out (update data ::s/problems #(take max-problems %))))))))
 
 #?(:clj
-(defn print-throwable
-  [^Throwable cause
-   & {:keys [trace? data? chain? data-level data-length trace-length explain-length]
-      :or {trace? true
-           data? true
-           chain? true
-           explain-length 10
-           data-length 10
-           data-level 3}}]
-  (letfn [(print-trace-element [^StackTraceElement e]
-            (let [class (.getClassName e)
-                  method (.getMethodName e)]
-              (let [match (re-matches #"^([A-Za-z0-9_.-]+)\$(\w+)__\d+$" (str class))]
-                (if (and match (= "invoke" method))
-                  (apply printf "%s/%s" (rest match))
-                  (printf "%s.%s" class method))))
-            (printf "(%s:%d)" (or (.getFileName e) "") (.getLineNumber e)))
-
-          (print-explain [explain]
-            (print "    xp: ")
-            (let [[line & lines] (str/lines explain)]
-              (print line)
-              (newline)
-              (doseq [line lines]
-                (println "       " line))))
-
-          (print-data [data]
-            (when (seq data)
-              (print "    dt: ")
-              (let [[line & lines] (str/lines (pprint-str data :level data-level :length data-length ))]
-                (print line)
-                (newline)
-                (doseq [line lines]
-                  (println "       " line)))))
-
-          (print-trace-title [cause]
-            (print   " →  ")
-            (printf "%s: %s" (.getName (class cause)) (first (str/lines (ex-message cause))))
-
-            (when-let [e (first (.getStackTrace cause))]
-              (printf " (%s:%d)" (or (.getFileName e) "") (.getLineNumber e)))
-
-            (newline))
-
-          (print-summary [cause]
-            (let [causes (loop [cause (.getCause cause)
-                                result []]
-                           (if cause
-                             (recur (.getCause cause)
-                                    (conj result cause))
-                             result))]
-              (println "TRACE:")
-              (print-trace-title cause)
-              (doseq [cause causes]
-                (print-trace-title cause))))
-
-          (print-trace [cause]
-            (print-trace-title cause)
-            (let [st (.getStackTrace cause)]
-              (print "    at: ")
-              (if-let [e (first st)]
-                (print-trace-element e)
-                (print "[empty stack trace]"))
-              (newline)
-
-              (doseq [e (if (nil? trace-length) (rest st) (take (dec trace-length) (rest st)))]
-                (print "        ")
-                (print-trace-element e)
-                (newline))))
-
-          (print-all [cause]
-            (print-summary cause)
-            (println "DETAIL:")
-            (when trace?
-              (print-trace cause))
-
-            (when data?
-              (when-let [data (ex-data cause)]
-                (if-let [explain (explain data)]
-                  (print-explain explain)
-                  (print-data data))))
-
-            (when chain?
-              (loop [cause cause]
-                (when-let [cause (.getCause cause)]
-                  (newline)
-                  (print-trace cause)
-
-                  (when data?
-                    (when-let [data (ex-data cause)]
-                      (if-let [explain (explain data)]
-                        (print-explain explain)
-                        (print-data data))))
-
-                  (recur cause)))))
-          ]
-
-    (println
-     (with-out-str
-       (print-all cause))))))
+   (defn print-throwable
+     [cause
+      & {:keys [trace? data? chain? data-level data-length trace-length explain-length]
+         :or {trace? true
+              data? true
+              chain? true
+              explain-length 10
+              data-length 10
+              data-level 3}}]
+     (letfn [(print-trace-element [^StackTraceElement e]
+               (let [class (.getClassName e)
+                     method (.getMethodName e)]
+                 (let [match (re-matches #"^([A-Za-z0-9_.-]+)\$(\w+)__\d+$" (str class))]
+                   (if (and match (= "invoke" method))
+                     (apply printf "%s/%s" (rest match))
+                     (printf "%s.%s" class method))))
+               (printf "(%s:%d)" (or (.getFileName e) "") (.getLineNumber e)))
+
+             (print-explain [explain]
+               (print "    xp: ")
+               (let [[line & lines] (str/lines explain)]
+                 (print line)
+                 (newline)
+                 (doseq [line lines]
+                   (println "       " line))))
+
+             (print-data [data]
+               (when (seq data)
+                 (print "    dt: ")
+                 (let [[line & lines] (str/lines (pprint-str data :level data-level :length data-length ))]
+                   (print line)
+                   (newline)
+                   (doseq [line lines]
+                     (println "       " line)))))
+
+             (print-trace-title [cause]
+               (print   " →  ")
+               (printf "%s: %s" (.getName (class cause)) (first (str/lines (ex-message cause))))
+
+               (when-let [e (first (.getStackTrace cause))]
+                 (printf " (%s:%d)" (or (.getFileName e) "") (.getLineNumber e)))
+
+               (newline))
+
+             (print-summary [cause]
+               (let [causes (loop [cause (.getCause cause)
+                                   result []]
+                              (if cause
+                                (recur (.getCause cause)
+                                       (conj result cause))
+                                result))]
+                 (println "TRACE:")
+                 (print-trace-title cause)
+                 (doseq [cause causes]
+                   (print-trace-title cause))))
+
+             (print-trace [cause]
+               (print-trace-title cause)
+               (let [st (.getStackTrace cause)]
+                 (print "    at: ")
+                 (if-let [e (first st)]
+                   (print-trace-element e)
+                   (print "[empty stack trace]"))
+                 (newline)
+
+                 (doseq [e (if (nil? trace-length) (rest st) (take (dec trace-length) (rest st)))]
+                   (print "        ")
+                   (print-trace-element e)
+                   (newline))))
+
+             (print-all [cause]
+               (print-summary cause)
+               (println "DETAIL:")
+               (when trace?
+                 (print-trace cause))
+
+               (when data?
+                 (when-let [data (ex-data cause)]
+                   (if-let [explain (explain data)]
+                     (print-explain explain)
+                     (print-data data))))
+
+               (when chain?
+                 (loop [cause cause]
+                   (when-let [cause (.getCause cause)]
+                     (newline)
+                     (print-trace cause)
+
+                     (when data?
+                       (when-let [data (ex-data cause)]
+                         (if-let [explain (explain data)]
+                           (print-explain explain)
+                           (print-data data))))
+
+                     (recur cause)))))
+             ]
+
+       (println
+        (with-out-str
+          (print-all cause))))))