Adding :with-repl option to start a clojure.main/repl in-between test execution

CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## NEXT
+
+- Can now use the `:with-repl` flag to start a REPL for interacting with your project.
+
 ## 0.13.0
 
 - Adds support for running tests once with the flag `:run-once`.
@@ -111,7 +115,7 @@ test namespace`.
 
 - Nothing. This was an accidental release due to testing the release
   script.
-  
+
 ## 0.3.7
 
 - Change success message to 'Passed all tests'

README.md

@@ -24,6 +24,7 @@ your `clojure.test` tests when a file in your project changes
 - Supports `clojure.test`'s custom reports.
 - Supports running your tests once! Useful for taking advantage of
   custom test reporters or quiet output in CI systems.
+- Has optional repl support for changing global state, such as timbre logging levels
 
 [sample.project.clj](sample.project.clj) show optional configuration.
 It and the rest of this readme should be used as documentation as to
@@ -62,10 +63,10 @@ output will look something like this.
     *************** Running tests ***************
 
     <standard clojure.test output>
-    
+
     Failed 1 of 215 assertions
     Finished at 08:25:20.619 (run time: 9.691s)
-    
+
 Your terminal will just stay like that. Fairly often `lein-test-refresh`
 polls the file system to see if anything has changed. When there is a
 change your code is tested again.
@@ -92,7 +93,7 @@ For example, if you want to send OSX notifications using
 you would add the following to your `project.clj` or `profiles.clj`
 
 ```clojure
-:test-refresh {:notify-command ["terminal-notifier" "-title" "Tests" "-message"]} 
+:test-refresh {:notify-command ["terminal-notifier" "-title" "Tests" "-message"]}
 ```
 
 `lein-test-refresh` also has built-in Growl support. To receive Growl
@@ -150,6 +151,16 @@ profiles.clj) or pass it as a command line option. Check out
 
 Using it at the command line looks like `lein test-refresh :run-once`.
 
+### Running with a REPL
+
+`lein-test-refresh` can be run with `:with-repl` which will start up a repl
+that you can interact with inbetween test runs. The main reason for this option
+is that sometimes you want to affect global state in your application.
+An example is when you see a test failure, you can call
+`(taoensso.timbre/set-level! :debug)` and see more information.
+
+See [this](https://github.com/jakemcc/lein-test-refresh/pull/50) pull request for details.
+
 ## Contributing
 
 I encourage pull requests. If you're making a large change it is

test-refresh/project.clj

@@ -12,6 +12,6 @@
                                       :username :gpg :password :gpg}]
                         ["releases" {:url "https://clojars.org/repo"
                                      :username :gpg :password :gpg}]]
-  :profiles {:dev {:dependencies [[org.clojure/clojure "1.6.0"]]}}
+  :profiles {:dev {:dependencies [[org.clojure/clojure "1.7.0"]]}}
   :scm {:name "git"
         :url "git@github.com:jakemcc/lein-test-refresh.git"})

test-refresh/src/com/jakemccrary/test_refresh.clj

@@ -163,13 +163,27 @@
 (defn- something-changed? [x y]
   (not= x y))
 
-(defn- monitor-keystrokes [keystroke-pressed]
+(def printing (atom false))
+
+(defn- monitor-keystrokes [keystroke-pressed with-repl?]
   (future
-    (loop [c (.read System/in)]
-      (if (= c -1)
-        (System/exit 0)
-        (do (reset! keystroke-pressed true)
-            (recur (.read System/in)))))))
+    (let [run-test-refresh! #(do (reset! keystroke-pressed true)
+                                 (reset! printing true))]
+      (if with-repl?
+        (clojure.main/repl
+          :prompt #(do (while @printing (Thread/sleep 100))
+                       (clojure.main/repl-prompt))
+          :read (fn [request-prompt request-exit]
+                  (if-let [line (read-line)]
+                    (if-not (empty? (clojure.string/trim line))
+                      (read-string line)
+                      (do (run-test-refresh!) :run-tests))
+                    (System/exit 0))))
+        (loop [c (.read System/in)]
+          (if (= c -1)
+            (System/exit 0)
+            (do (run-test-refresh!)
+                (recur (.read System/in)))))))))
 
 (defn- create-user-notifier [notify-command]
   (let [notify-command (if (string? notify-command)
@@ -198,20 +212,24 @@
         keystroke-pressed (atom nil)
         selectors (second (:nses-and-selectors options))
         report (:report options)
-        run-once? (:run-once options)]
+        run-once? (:run-once options)
+        with-repl? (:with-repl options)
+        monitoring? (atom false)]
 
     (when report
       (println "Using reporter:" report))
     (when (:quiet options)
       (defmethod capture-report :begin-test-ns [m]))
 
-    (when-not run-once? (monitor-keystrokes keystroke-pressed))
     (loop [tracker (make-change-tracker)]
-      (let [new-tracker (scan-for-changes tracker)]
+      (let [new-tracker (scan-for-changes tracker)
+            something-changed? (something-changed? new-tracker tracker)]
         (try
-          (when (or @keystroke-pressed
-                    (something-changed? new-tracker tracker))
+          (when (or @keystroke-pressed something-changed?)
             (reset! keystroke-pressed nil)
+            (reset! printing true)
+
+            (when (and with-repl? @monitoring? something-changed?) (println))
             (print-banner)
 
             (let [was-failed (tracking-failed-tests?)
@@ -227,7 +245,17 @@
               (when (should-notify? result)
                 (when should-growl
                   (growl (:status result) (:message result)))
-                (users-notifier (:message result)))))
+                (users-notifier (:message result))))
+            (reset! printing false)
+
+            (when (and with-repl? @monitoring? something-changed?)
+              (clojure.main/repl-prompt)
+              (flush))
+
+            (when (and (not run-once?)
+                       (not @monitoring?))
+              (monitor-keystrokes keystroke-pressed with-repl?)
+              (reset! monitoring? true)))
           (catch Exception ex (.printStackTrace ex)))
         (Thread/sleep 200)
         (if-not run-once?

test-refresh/src/leiningen/test_refresh.clj

@@ -14,16 +14,17 @@
                (:test-paths project []))))
 
 (defn parse-commandline [project args]
-  (let [{:keys [notify-command notify-on-success growl silence quiet report changes-only run-once]} (:test-refresh project)
+  (let [{:keys [notify-command notify-on-success growl silence quiet report changes-only run-once with-repl]} (:test-refresh project)
         should-growl (or (some #{:growl ":growl" "growl"} args) growl)
         changes-only (or (some #{:changes-only ":changes-only" "changes-only"} args) changes-only)
         run-once? (or (some #{:run-once ":run-once" "run-once"} args) run-once)
+        with-repl? (or (some #{:with-repl ":with-repl" "with-repl"} args) with-repl)
         args (remove #{:growl ":growl" "growl"
                        :changes-only ":changes-only" "changes-only"
+                       :with-repl ":with-repl" "with-repl"
                        :run-once ":run-once" "run-once"} args)
         notify-on-success (or (nil? notify-on-success) notify-on-success)
-        selectors (filter keyword? args)
-        ]
+        selectors (filter keyword? args)]
     {:growl should-growl
      :changes-only changes-only
      :notify-on-success notify-on-success
@@ -32,7 +33,8 @@
      :test-paths (clojure-test-directories project)
      :quiet quiet
      :report report
-     :run-once run-once?}))
+     :run-once run-once?
+     :with-repl with-repl?}))
 
 (defn test-refresh
   "Autoruns clojure.test tests on source change or